Compare commits

..
1514 Commits
Author SHA1 Message Date
Marius UngureanuandMartin Baulig df99fccf69 Apply suggestions from code review
Co-Authored-By: Martin Baulig <[email protected]>
2019-05-31 12:08:46 +02:00
Marius Ungureanu 27554bf06b Plug leak of CustomAttribute initializer name
All the CustomAttribute initializer names (fields, property) except the last were leaked. Ensure all names are freed.

Fixes #14543
2019-05-31 12:08:46 +02:00
Vlad Brezae ddf393026a [marshal] Fix race between delegate marshaling and finalization
When passing a delegate to native code, we pass the delegate_trampoline which can be used to invoke the delegate from native code and we store this mapping (delegate_trampoline->delegate) in a hashtable so we can get a delegate for the delegate_trampoline, when marshalling the opposite way. If we are trying to marshal a ftnptr (for managed code) to a delegate and we don't find this mapping we can crash. This could happen if the finalization for some other delegate that uses the same ftnptr removes this entry from the table. We solve this by never freeing these entries. The first delegate-ftnptr pair will always be alive. This is easier, faster and potentially uses less memory than tracking in the hashtable every pair. There should be a small and limited set of methods marshalled to native.

Fixes https://github.com/mono/mono/issues/13231
2019-05-31 12:05:50 +02:00
Alexander Köplinger 4181954955 [bcl] Add nunit exclude categories for monotouch/monodroid profiles (#14695)
We didn't set all the categories that the products used in our profiles.

Now that the products can consume the exclude categories from mono we
need to unify the values.

Removed ValueAdd since it's not used anymore and combined MacNotWorking
into NotOnMac.

(cherry picked from commit f46191114b)
2019-05-29 17:00:41 +02:00
Alexander Köplinger 0ca2187eb3 [System] Fix MultiCastOptionTest on WatchOS
With https://github.com/mono/mono/commit/cf69b4725976e51416bfdff22f3e1834006af00a it started doing DNS lookups for localhost and we don't have sockets on the watch.

(cherry picked from commit 4fcbbd8fb7)
2019-05-29 16:45:47 +02:00
Alexander Köplinger 197461e034 [sdks] Only package android-sources on macOS
rsync might not be installed on other platforms and we only need android-sources in one sdks archive.

(cherry picked from commit edd6c013b0)
2019-05-29 00:30:56 +02:00
Alexander Köplinger 356964caf2 [sdks] Don't package android-sources on Windows
We don't need it there.

(cherry picked from commit a2f66ddca1)
2019-05-28 19:50:49 +02:00
Alexander Köplinger 271b64409d [sdks] Add linker sources to android sdks archive (#14686)
(cherry picked from commit c96878fb16)
2019-05-28 18:56:11 +02:00
Alexander Köplinger 1e2119b6df [bcl] Write newline-separated nunit/xunit excludes file for sdks archive (#14681)
During XI integration we noticed that just using the verbatim commandline
-exclude or -notrait is not ideal since XI uses the nunit/xunit APIs to
pass that information and not the command line parser.

Instead we now write the exclude categories/traits as a newline-separated file.

(cherry picked from commit 07c58ee2ed)
2019-05-28 18:51:43 +02:00
monojenkins da671d0b3c [2019-04] [mscorlib] Ensure monotouch[_runtime] API are identical (#14680)
* [mscorlib] Ensure monotouch[_runtime] API are identical

Ensure the API surface for `mscorlib.Core.dll` is identical between the
`monotouch` and `monotouch_runtime` (used for REPL and the interpreter).

This ensure code compiled against one will be fine when building against
the other (e.g. avoiding linker errors).

In practice this means:

1. Expose the API needed for `System.Reflection.Emit` in XI

	- throwing `PlatformNotSupportedException` **by default**; or
	- calling the mono runtime when the interpreter is enabled;

2. Do not expose additional, not supported, API (e.g. COM related)

	- `monotouch_runtime` configuration was built without `FULL_AOT_RUNTIME`
	  and that brings some other stuff that is not AOT related

Follow up to #14606

Existing diff

Removed methods:

```csharp
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access);
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, System.Collections.Generic.IEnumerable<Reflection.Emit.CustomAttributeBuilder> assemblyAttributes);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.Policy.Evidence evidence);
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir);
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, System.Collections.Generic.IEnumerable<Reflection.Emit.CustomAttributeBuilder> assemblyAttributes, Security.SecurityContextSource securityContextSource);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, bool isSynchronized, System.Collections.Generic.IEnumerable<Reflection.Emit.CustomAttributeBuilder> assemblyAttributes);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions, bool isSynchronized);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions, bool isSynchronized, System.Collections.Generic.IEnumerable<Reflection.Emit.CustomAttributeBuilder> assemblyAttributes);
```

Removed methods:

```csharp
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.Policy.Evidence evidence);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions, bool isSynchronized);
```

Added constructor:

```csharp
public AssemblyBuilder ();
```

Removed properties:

```csharp
public override string CodeBase { get; }
public override System.Reflection.MethodInfo EntryPoint { get; }
public override string EscapedCodeBase { get; }
public override System.Security.Policy.Evidence Evidence { get; }
public override string FullName { get; }
public override bool GlobalAssemblyCache { get; }
public override string ImageRuntimeVersion { get; }
public override bool IsDynamic { get; }
public override string Location { get; }
public override System.Reflection.Module ManifestModule { get; }
public override bool ReflectionOnly { get; }
```

Removed methods:

```csharp
public void AddResourceFile (string name, string fileName);
public void AddResourceFile (string name, string fileName, System.Reflection.ResourceAttributes attribute);
public ModuleBuilder DefineDynamicModule (string name, bool emitSymbolInfo);
public ModuleBuilder DefineDynamicModule (string name, string fileName);
public ModuleBuilder DefineDynamicModule (string name, string fileName, bool emitSymbolInfo);
public System.Resources.IResourceWriter DefineResource (string name, string description, string fileName);
public System.Resources.IResourceWriter DefineResource (string name, string description, string fileName, System.Reflection.ResourceAttributes attribute);
public void DefineUnmanagedResource (byte[] resource);
public void DefineUnmanagedResource (string resourceFileName);
public void DefineVersionInfoResource ();
public void DefineVersionInfoResource (string product, string productVersion, string company, string copyright, string trademark);
public override bool Equals (object obj);
public override object[] GetCustomAttributes (bool inherit);
public override object[] GetCustomAttributes (System.Type attributeType, bool inherit);
public override System.Type[] GetExportedTypes ();
public override System.IO.FileStream GetFile (string name);
public override System.IO.FileStream[] GetFiles (bool getResourceModules);
public override int GetHashCode ();
public override System.Reflection.Module[] GetLoadedModules (bool getResourceModules);
public override System.Reflection.ManifestResourceInfo GetManifestResourceInfo (string resourceName);
public override string[] GetManifestResourceNames ();
public override System.IO.Stream GetManifestResourceStream (string name);
public override System.IO.Stream GetManifestResourceStream (System.Type type, string name);
public override System.Reflection.Module GetModule (string name);
public override System.Reflection.Module[] GetModules (bool getResourceModules);
public override System.Reflection.AssemblyName GetName (bool copiedName);
public override System.Reflection.AssemblyName[] GetReferencedAssemblies ();
public override System.Reflection.Assembly GetSatelliteAssembly (System.Globalization.CultureInfo culture);
public override System.Reflection.Assembly GetSatelliteAssembly (System.Globalization.CultureInfo culture, System.Version version);
public override System.Type GetType (string name, bool throwOnError, bool ignoreCase);
public override bool IsDefined (System.Type attributeType, bool inherit);
public void Save (string assemblyFileName);
public void Save (string assemblyFileName, System.Reflection.PortableExecutableKinds portableExecutableKind, System.Reflection.ImageFileMachine imageFileMachine);
public void SetEntryPoint (System.Reflection.MethodInfo entryMethod, PEFileKinds fileKind);
public override string ToString ();
```

Added constructor:

```csharp
public ConstructorBuilder ();
```

Removed properties:

```csharp
public override System.Reflection.CallingConventions CallingConvention { get; }
public override System.Reflection.Module Module { get; }

[Obsolete]
public System.Type ReturnType { get; }
```

Removed methods:

```csharp
public void AddDeclarativeSecurity (System.Security.Permissions.SecurityAction action, System.Security.PermissionSet pset);
public void SetSymCustomAttribute (string name, byte[] data);
public override string ToString ();
```

Removed property:

```csharp
public override System.Reflection.Module Module { get; }
```

Added property:

```csharp
public override System.Reflection.MethodImplAttributes MethodImplementationFlags { get; }
```

Removed methods:

```csharp
public override System.Delegate CreateDelegate (System.Type delegateType);
public override System.Delegate CreateDelegate (System.Type delegateType, object target);
public override string ToString ();
```

Added properties:

```csharp
public override bool IsByRefLike { get; }
public override bool IsSZArray { get; }
public override bool IsVariableBoundArray { get; }
```

Removed method:

```csharp
public override bool IsAssignableFrom (System.Reflection.TypeInfo typeInfo);
```

Added constructor:

```csharp
public EventBuilder ();
```

Removed properties:

```csharp
public override int MetadataToken { get; }
public override System.Reflection.Module Module { get; }
```

Removed method:

```csharp
[Obsolete ("An alternate API is available: Emit the MarshalAs custom attribute instead.")]
public void SetMarshal (UnmanagedMarshal unmanagedMarshal);
```

Added properties:

```csharp
public override bool IsByRefLike { get; }
public override bool IsConstructedGenericType { get; }
public override bool IsSZArray { get; }
public override bool IsTypeDefinition { get; }
public override bool IsVariableBoundArray { get; }
```

Removed methods:

```csharp
public override System.Type[] GetGenericParameterConstraints ();
public override bool IsAssignableFrom (System.Reflection.TypeInfo typeInfo);
public override bool IsInstanceOfType (object o);
```

Modified properties:

```diff
-public virtual int ILOffset { get; }
+public int ILOffset { get; }
```

Removed method:

```csharp
public virtual void MarkSequencePoint (System.Diagnostics.SymbolStore.ISymbolDocumentWriter document, int startLine, int startColumn, int endLine, int endColumn);
```

Added property:

```csharp
public override bool IsConstructedGenericMethod { get; }
```

Removed methods:

```csharp
public void AddDeclarativeSecurity (System.Security.Permissions.SecurityAction action, System.Security.PermissionSet pset);

[Obsolete ("An alternate API is available: Emit the MarshalAs custom attribute instead.")]
public void SetMarshal (UnmanagedMarshal unmanagedMarshal);
public void SetSymCustomAttribute (string name, byte[] data);
```

Removed properties:

```csharp
public override int MetadataToken { get; }
public override System.Guid ModuleVersionId { get; }
public override string ScopeName { get; }
```

Removed methods:

```csharp
public System.Diagnostics.SymbolStore.ISymbolDocumentWriter DefineDocument (string url, System.Guid language, System.Guid languageVendor, System.Guid documentType);
public void DefineManifestResource (string name, System.IO.Stream stream, System.Reflection.ResourceAttributes attribute);
public System.Resources.IResourceWriter DefineResource (string name, string description);
public System.Resources.IResourceWriter DefineResource (string name, string description, System.Reflection.ResourceAttributes attribute);
public void DefineUnmanagedResource (byte[] resource);
public void DefineUnmanagedResource (string resourceFileName);
public override object[] GetCustomAttributes (bool inherit);
public override object[] GetCustomAttributes (System.Type attributeType, bool inherit);
public override System.Reflection.FieldInfo GetField (string name, System.Reflection.BindingFlags bindingAttr);
public override System.Reflection.FieldInfo[] GetFields (System.Reflection.BindingFlags bindingFlags);
protected override System.Reflection.MethodInfo GetMethodImpl (string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Reflection.CallingConventions callConvention, System.Type[] types, System.Reflection.ParameterModifier[] modifiers);
public override System.Reflection.MethodInfo[] GetMethods (System.Reflection.BindingFlags bindingFlags);
public System.Diagnostics.SymbolStore.ISymbolWriter GetSymWriter ();
public override System.Type GetType (string className);
public override System.Type GetType (string className, bool ignoreCase);
public override System.Type GetType (string className, bool throwOnError, bool ignoreCase);
public override System.Type[] GetTypes ();
public override bool IsDefined (System.Type attributeType, bool inherit);
public override bool IsResource ();
public override System.Reflection.FieldInfo ResolveField (int metadataToken, System.Type[] genericTypeArguments, System.Type[] genericMethodArguments);
public override System.Reflection.MemberInfo ResolveMember (int metadataToken, System.Type[] genericTypeArguments, System.Type[] genericMethodArguments);
public override System.Reflection.MethodBase ResolveMethod (int metadataToken, System.Type[] genericTypeArguments, System.Type[] genericMethodArguments);
public override byte[] ResolveSignature (int metadataToken);
public override string ResolveString (int metadataToken);
public override System.Type ResolveType (int metadataToken, System.Type[] genericTypeArguments, System.Type[] genericMethodArguments);
public void SetSymCustomAttribute (string name, byte[] data);
```

Modified properties:

```diff
-public virtual int Attributes { get; }
+public int Attributes { get; }
-public virtual string Name { get; }
+public string Name { get; }
-public virtual int Position { get; }
+public int Position { get; }
```

Removed method:

```csharp
[Obsolete ("An alternate API is available: Emit the MarshalAs custom attribute instead.")]
public virtual void SetMarshal (UnmanagedMarshal unmanagedMarshal);
```

Removed interface:

```csharp
System.Runtime.InteropServices._SignatureHelper
```

Removed methods:

```csharp
public override bool Equals (object obj);
public override int GetHashCode ();
public override string ToString ();
```

Removed property:

```csharp
public override bool ContainsGenericParameters { get; }
```

Added properties:

```csharp
public override bool IsByRefLike { get; }
public override bool IsSZArray { get; }
public override bool IsSecurityCritical { get; }
public override bool IsSecuritySafeCritical { get; }
public override bool IsSecurityTransparent { get; }
public override bool IsVariableBoundArray { get; }
```

Removed methods:

```csharp
public void AddDeclarativeSecurity (System.Security.Permissions.SecurityAction action, System.Security.PermissionSet pset);
public override bool IsAssignableFrom (System.Reflection.TypeInfo typeInfo);
protected override bool IsValueTypeImpl ();
```

Removed methods:

```csharp
public static object GetActiveObject (string progID);
public static IntPtr GetComInterfaceForObjectInContext (object o, System.Type t);
public static int GetComSlotForMethodInfo (System.Reflection.MemberInfo m);
public static int GetEndComSlot (System.Type t);
public static IntPtr GetExceptionPointers ();
public static IntPtr GetIDispatchForObjectInContext (object o);
public static IntPtr GetITypeInfoForType (System.Type t);
public static IntPtr GetIUnknownForObjectInContext (object o);

[Obsolete ("This method has been deprecated")]
public static IntPtr GetManagedThunkForUnmanagedMethodPtr (IntPtr pfnMethodToWrap, IntPtr pbSignature, int cbSignature);
public static System.Reflection.MemberInfo GetMethodInfoForComSlot (System.Type t, int slot, ref ComMemberType memberType);

[Obsolete ("This method has been deprecated")]
public static System.Threading.Thread GetThreadFromFiberCookie (int cookie);
public static System.Type GetTypeForITypeInfo (IntPtr piTypeInfo);

[Obsolete]
public static string GetTypeInfoName (UCOMITypeInfo pTI);
public static System.Guid GetTypeLibGuid (ComTypes.ITypeLib typelib);

[Obsolete]
public static System.Guid GetTypeLibGuid (UCOMITypeLib pTLB);
public static System.Guid GetTypeLibGuidForAssembly (System.Reflection.Assembly asm);
public static int GetTypeLibLcid (ComTypes.ITypeLib typelib);

[Obsolete]
public static int GetTypeLibLcid (UCOMITypeLib pTLB);
public static string GetTypeLibName (ComTypes.ITypeLib typelib);

[Obsolete]
public static string GetTypeLibName (UCOMITypeLib pTLB);
public static void GetTypeLibVersionForAssembly (System.Reflection.Assembly inputAssembly, out int majorVersion, out int minorVersion);

[Obsolete ("This method has been deprecated")]
public static IntPtr GetUnmanagedThunkForManagedMethodPtr (IntPtr pfnMethodToWrap, IntPtr pbSignature, int cbSignature);
public static bool IsTypeVisibleFromCom (System.Type t);
public static int NumParamBytes (System.Reflection.MethodInfo m);

[Obsolete]
public static void ReleaseThreadCache ();
```

* [csproj] Update project files

* Bump API snapshot submodule
2019-05-28 14:48:24 +02:00
Alexander Köplinger af47bd50b2 [sdks] Explicitly set version of the mac/ios/watchos/tvos platform SDKs (#14663)
Otherwise the Xcode linker tries to guess the version from the path,
and since we use Xcode101.app it'd use sdk=101 as the version which is wrong.

By explicitly specifying e.g. `$(XCODE_DIR)/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS12.1.sdk`
as the sysroot it correctly guesses sdk=12.1 instead.

See also https://github.com/xamarin/xamarin-macios/commit/834c0a9fd7062c0c25011721fd7d524b8a60b41e

(cherry picked from commit 7ca8e89ce7)
2019-05-28 01:39:17 +02:00
monojenkins 4766e2227a [2019-04] [System] Fix monotouch_runtime repl assemblies (#14638)
They were missing some exclude files that caused unnecessary p/invokes to be retained.

Fixes https://github.com/mono/mono/issues/13526
2019-05-27 14:01:57 +02:00
monojenkins 02d008c624 [2019-04] [System.Core] Ensure monotouch[_runtime] API are identical (#14617)
* [System.Core] Ensure monotouch[_runtime] API are identical

Ensure the API surface for `System.Core.dll` is identical between the
`monotouch` and `monotouch_runtime` (used for REPL and the interpreter).

This ensure code compiled against one will be fine when building against
the other (e.g. avoiding linker errors).

Removed methods:

```csharp
public void CompileToMethod (System.Reflection.Emit.MethodBuilder method);
public void CompileToMethod (System.Reflection.Emit.MethodBuilder method, System.Runtime.CompilerServices.DebugInfoGenerator debugInfoGenerator);
```

Removed methods:

```csharp
[Obsolete ("do not use this method")]
public static IRuntimeVariables MergeRuntimeVariables (IRuntimeVariables first, IRuntimeVariables second, int[] indexes);

[Obsolete ("do not use this method")]
public static System.Linq.Expressions.Expression Quote (System.Linq.Expressions.Expression expression, object hoistedLocals, object[] locals);
```

* [csproj] Update project files

* Bump API snapshot submodule
2019-05-24 15:39:50 +02:00
monojenkins 0c0df14755 [2019-04] Throw ObjectDisposedException instead of crashing when Cairo.Context handle == IntPtr.Zero (#14626)
* Throw ObjectDisposedException instead of crashing when Cairo.Context.handle == IntPtr.Zero

We are seeing instances where VS for Mac is crashing with a SIGSEGV when
calling into certain Cairo.Context functions.  Looking at the code, it's clear
that it's possible to have Context.handle == IntPtr.Zero after disposing the
object.

From research, it looks like passing a nullptr to raw cairo functions can
result in a SIGSEGV:
    https://bugs.launchpad.net/ubuntu/+source/compiz/+bug/93807

This change adds check to see if Conext.handle == IntPtr.Zero in Context
painting, font, and path methods.  This will turn uncatchable SIGSEGVs
into ObjectDisposedException.

* Update Context.cs

* Ensure SetTarget results in a valid handle
2019-05-24 15:20:08 +02:00
Alexander Köplinger 9a3a2665f0 [sdks] Fix min OSX version of runtime files in Mac SDK (#14615)
It was using an unescaped makefile variable in the template, i.e. ended up empty which meant the build just took the host version as the min version.

Fixed the variable and also moved it to CFLAGS/CXXFLAGS instead of CPPFLAGS to be consistent with ios.mk

(cherry picked from commit 82a9931248)
2019-05-24 14:11:21 +02:00
Alexander Köplinger c01bc7bca9 [tests] Add xunit.execution.dotnet.dll to tests directory (#14595)
So it gets included in the sdks archive

(cherry picked from commit f5f3c6aabe)
2019-05-23 20:18:42 +02:00
Bernhard Urban 9d909ca613 [arm] one more attempt to fix slotsize issue on llvmonly (#14444) (#14534)
[2019-04] [arm] one more attempt to fix slotsize issue on llvmonly (#14444)

Backport of https://github.com/mono/mono/pull/14444
2019-05-23 10:00:37 -04:00
Marek Habersack 26b9087b44 [Android] Fix runtime loading of DSOs for 64-bit processes
Context: https://github.com/xamarin/xamarin-android/issues/2780

On Android the executable for the application is going to be
`/system/bin/app_process{32,64}` depending on the application's architecture.
However, libraries for the different architectures live in different
subdirectories of `/system`: `lib` for 32-bit apps and `lib64` for 64-bit ones.
Thus appending `/lib` below will fail to load the DSO for a 64-bit app, even if
it exists there, because it will have a different architecture. The quickest fix
is to use `lib64` explicitly for 64-bit Android apps.
2019-05-23 10:46:30 +02:00
Alexander Köplinger a3d0f993c2 [tests] Add Xunit.NetCore.Extensions.dll to tests directory (#14571)
So it gets included in the sdks archive

(cherry picked from commit 2c76de1ee1)
2019-05-22 19:48:58 +02:00
Alexander Köplinger 92e73f22ea [2019-04] Bump gtk-sharp in bockbuild
Brings in mono/gtk-sharp#273.

Cherry-pick of https://github.com/mono/mono/pull/14537
2019-05-21 11:39:07 +02:00
monojenkins 4caae35744 [interp] disable inlining for built-in types (#14530)
[2019-04] [interp] disable inlining for built-in types

Fixes https://github.com/mono/mono/issues/14246

Backport of #14501.

/cc @lewurm
2019-05-20 16:16:11 -04:00
Alexander Köplinger d4e20f02e8 [sdks] Lipo arm64_32 binaries for watchOS
(cherry picked from commit ca5e8f207b)
2019-05-12 17:48:09 -07:00
monojenkins f506b6556b [2019-04] [WinForms] fix EditingCellFormattedValue getter and setter for bool value (#14436)
* [WinForms] If DataGridViewCheckBoxCell not in threeState mode EditingCellFormattedValue must return true or false, instead of value of CheckState type

* [WinForms] DataGrid: fix type check in EditingCellFormattedValue setter. When set bool value to EditingCellFormattedValue there will be exception. Type equality must be done through IsAssignableFrom not direct

* [WinForms] DataGrid: Add test for EditingCellFormattedValue getter and setter.
2019-05-12 05:39:39 -07:00
monojenkins cfd117ef41 [2019-04] Revert "[System] Add FSEvent FileSystemWatcher to monotouch BCL profile" (#14447)
* Revert "[System] Add FSEvent FileSystemWatcher to 'monotouch' BCL profile"

This reverts commit 46fc5352f3dfe0027e684a0f61e71130fccd559f.

While iOS FileSystemWatcher works, we now find that it is used unofficially-available  symbols and cannot publish apps using those.

Fixes https://github.com/mono/mono/issues/14290

* [csproj] Update project files
2019-05-12 05:21:40 -07:00
monojenkins 719fd63c43 [2019-04] [runtime] Use MAP_JIT automatically when running under a hardened runtime on osx. (#14414)
* [runtime] Use MAP_JIT automatically when running under a hardened runtime on osx.

* Fix memory ordering.
2019-05-12 05:19:22 -07:00
monojenkins 7bcbc7c2bf [2019-04] [corlib] Implement AssemblyBuilder.get_ReflectionOnly() (#14457)
* [corlib] Implement AssemblyBuilder.get_ReflectionOnly()

Fixes #13028

* Bump API snapshot submodule
2019-05-12 05:11:27 -07:00
monojenkins 3ac7efc336 [arm64] set MONO_ARCH_HAVE_UNWIND_BACKTRACE for watch4 (#14453)
[2019-04] [arm64] set MONO_ARCH_HAVE_UNWIND_BACKTRACE for watch4

Fixes a couple of mscorlib test failures, failing with
> Stack walks are not supported on this platform


Backport of #14440.

/cc @lewurm
2019-05-11 09:15:44 -04:00
monojenkins 482111976a [metadata] use handle stack in mono_runtime_object_init_handle (#14446)
[2019-04] [metadata] use handle stack in mono_runtime_object_init_handle

Fixes this crash on watchOS with llvmonly:
https://gist.github.com/lewurm/921b77a238c6fd60757a5ee9f54279d1

The hint here was that the crash happened in `mono_handle_stack_scan ()` and inspecting the handle stack there. After enabling `MONO_HANDLE_TRACK_OWNER` and `MONO_HANDLE_TRACK_SP` in `handle.h`, I got this:
https://gist.github.com/lewurm/71f936a126879ef2b96d00399e6b2bd9


@lambdageek suggested this fix after showing this trace to him. As far as I understand we do _not_ know the root cause yet. The handle leak happens in this trace:
https://gist.github.com/lewurm/b76fbc391f22d897bfd532ac1b67e2aa
`mono_runtime_object_init_checked ()` already should take care of the handle stack 😕


Contributes to #13006

Backport of #14399.

/cc @akoeplinger @lewurm
2019-05-10 18:06:04 -04:00
Egor Bogatov 7a8db67341 Update CultureInfoTest.cs 2019-05-10 13:54:54 +02:00
Egor Bogatov dce3386dbb Fix TextView 2019-05-10 13:54:54 +02:00
lateralusX ad01218417 Mutex memory leak on sgen GC (nursery, major).
During GC we allocate a gray queue protected by a mutex, sgen_gray_object_queue_init.
This mutex is never destroyed when clearing up the object containing it,
sgen_gray_object_queue_dispose, so it will leak. Overtime this could cause
OOM on some systems depending on how memory related to system primitives are
handled and partitioned.
2019-05-10 11:08:31 +02:00
Bernhard Urban b8a6096bb1 [2019-04] Do not allocate handles in ReleaseMutex. (#14429)
[2019-04] Do not allocate handles in ReleaseMutex.

Backport of https://github.com/mono/mono/pull/14403
2019-05-10 04:32:27 -04:00
monojenkins c35f4c3e5f Usually do not create a handle in mono_runtime_invoke_handle. Use mono_runtime_invoke_handle_void instead. (#14422)
[2019-04] Usually do not create a handle in mono_runtime_invoke_handle.

Use mono_runtime_invoke_handle_void instead.


Backport of #14404.

/cc @lewurm @jaykrell
2019-05-09 20:15:36 -04:00
Ankit Jain 08d062aca7 Bump msbuild to track mono-2019-04 (#14287) 2019-05-09 12:38:50 -04:00
monojenkins 82601ba547 [llvmonly] make local copy of trace_ips pointer from exception object (#14410)
[2019-04] [llvmonly] make local copy of trace_ips pointer from exception object

Fixes a race in llvmonly (watchOS):
```
Process 397 stopped
* thread %10, name = 'tid_8e2f', stop reason = EXC_BAD_ACCESS (code=1, address=0x28)
    frame %0: 0x0177f690 mscorlibtests`mono_llvm_load_exception at mini-exceptions.c:3886:23
   3883                 size_t upper = mono_array_length_internal (mono_ex->trace_ips);
   3884
   3885                 for (int i = 0; i < upper; i += TRACE_IP_ENTRY_SIZE) {
-> 3886                         gpointer curr_ip = mono_array_get_internal (mono_ex->trace_ips, gpointer, i);
   3887                         for (int j = 0; j < TRACE_IP_ENTRY_SIZE; ++j) {
   3888                                 gpointer p = mono_array_get_internal (mono_ex->trace_ips, gpointer, i + j);
   3889                                 trace_ips = g_list_append (trace_ips, p);
Target 0: (mscorlibtests) stopped.

(lldb) mbt
* thread %10
  * frame %0: 0x0177f690 mscorlibtests`mono_llvm_load_exception at mini-exceptions.c:3886:23
    frame %1: 0x00e23b7a mscorlibtests`mscorlibtests1_MonoTests_System_LazyTest__c__DisplayClass16_0__ConcurrentInitializationb__1 + 254
    frame %2: 0x0087af98 mscorlibtests`mscorlib_wrapper_delegate_invoke__Module_invoke_void + 610
    frame %3: 0x00368856 mscorlibtests`mscorlib_System_Threading_ThreadHelper_ThreadStart_Context_object + 448
  [...]
(lldb) p/x mono_ex
(MonoException *) $2 = 0x01d9e968
(lldb) p/x mono_ex->trace_ips
(MonoArray *) $3 = 0x00000000
(lldb) thread list
Process 397 stopped
  thread %1: tid = 0x38772, 0x018156aa mscorlibtests`jit_info_table_copy_and_split_chunk(table=0x17635a00, chunk=0x17b767f0) at jit-info.c:483:28, name = 'tid_303', queue = 'com.apple.main-thread'
  thread %3: tid = 0x387ad, 0x1c4f9764 libsystem_kernel.dylib`__psynch_cvwait + 24, name = 'SGen worker'
  thread %4: tid = 0x387b0, 0x1c4f1224 libsystem_kernel.dylib`semaphore_wait_trap + 8, name = 'Finalizer'
  thread %5: tid = 0x387b5, 0x1c4fa6cc libsystem_kernel.dylib`__workq_kernreturn + 8
  thread %6: tid = 0x387b6, 0x1c4f11d4 libsystem_kernel.dylib`mach_msg_trap + 20, name = 'com.apple.uikit.eventfetch-thread'
* thread %10: tid = 0x389a6, 0x0177f690 mscorlibtests`mono_llvm_load_exception at mini-exceptions.c:3886:23, name = 'tid_8e2f', stop reason = EXC_BAD_ACCESS (code=1, address=0x28)
  thread %11: tid = 0x38985, 0x1c4f9764 libsystem_kernel.dylib`__psynch_cvwait + 24, name = 'tid_8113'
  thread %12: tid = 0x38986, 0x1c4f123c libsystem_kernel.dylib`semaphore_timedwait_trap + 8, name = 'Thread Pool Worker'
  thread %13: tid = 0x38987, 0x1c4f123c libsystem_kernel.dylib`semaphore_timedwait_trap + 8, name = 'Thread Pool Worker'
  thread %14: tid = 0x389a3, 0x1c4f123c libsystem_kernel.dylib`semaphore_timedwait_trap + 8, name = 'Thread Pool Worker'
  thread %15: tid = 0x389a4, 0x1c4f123c libsystem_kernel.dylib`semaphore_timedwait_trap + 8, name = 'Thread Pool Worker'
  thread %16: tid = 0x389a5, 0x1c4f123c libsystem_kernel.dylib`semaphore_timedwait_trap + 8, name = 'Thread Pool Worker'
(lldb) thread select 1
* thread %1, name = 'tid_303', queue = 'com.apple.main-thread'
    frame %0: 0x018156aa mscorlibtests`jit_info_table_copy_and_split_chunk(table=0x17635a00, chunk=0x17b767f0) at jit-info.c:483:28
   480                          jit_info_table_split_chunk (chunk, &new_table->chunks [j], &new_table->chunks [j + 1]);
   481                          j += 2;
   482                  } else {
-> 483                          new_table->chunks [j] = table->chunks [i];
   484                          ++new_table->chunks [j]->refcount;
   485                          ++j;
   486                  }
(lldb) mbt
* thread %1
  * frame %0: 0x018156aa mscorlibtests`jit_info_table_copy_and_split_chunk(table=0x17635a00, chunk=0x17b767f0) at jit-info.c:483:28
    frame %1: 0x01815304 mscorlibtests`jit_info_table_chunk_overflow(table=0x17635a00, chunk=0x17b767f0) at jit-info.c:579:10
    frame %2: 0x018146ee mscorlibtests`jit_info_table_add(domain=0x16624cc0, table_ptr=0x16624d9c, ji=0x176f4428) at jit-info.c:614:33
    frame %3: 0x01814662 mscorlibtests`mono_jit_info_table_add(domain=0x16624cc0, ji=0x176f4428) at jit-info.c:674:2
    frame %4: 0x0175f5da mscorlibtests`mono_aot_find_jit_info(domain=0x16624cc0, image=0x16c07200, addr=0x00271ff1) at aot-runtime.c:3710:3
    frame %5: 0x0181443e mscorlibtests`mono_jit_info_table_find_internal(domain=0x16624cc0, addr=0x00271ff1, try_aot=1, allow_trampolines=0) at jit-info.c:306:9
    frame %6: 0x018145e0 mscorlibtests`mono_jit_info_table_find(domain=0x16624cc0, addr=0x00271ff1) at jit-info.c:335:9
    frame %7: 0x01780212 mscorlibtests`build_stack_trace(frame_ctx=0x01c2fb18, state=0x01c2ffb8) at mini-exceptions.c:392:31
    frame %8: 0x1c598aa2 libunwind.dylib`_Unwind_Backtrace + 232
    frame %9: 0x0177f4fc mscorlibtests`throw_exception(ex=0x01d9e968, rethrow=0) at mini-exceptions.c:3800:3
    frame %10: 0x0177f3c8 mscorlibtests`mono_llvm_throw_exception(ex=0x01d9e968) at mini-exceptions.c:3823:2
    frame %11: 0x00439ed0 mscorlibtests`mscorlib_System_Runtime_ExceptionServices_ExceptionDispatchInfo_Throw + 116
    frame %12: 0x00271ff0 mscorlibtests`mscorlib_System_LazyHelper_ThrowException + 98
    frame %13: 0x002730c2 mscorlibtests`mscorlib_System_Lazy_1_T_REF_CreateValue + 194
    frame %14: 0x00273390 mscorlibtests`mscorlib_System_Lazy_1_T_REF_get_Value + 128
    frame %15: 0x0027307a mscorlibtests`mscorlib_System_Lazy_1_T_REF_CreateValue + 122
    frame %16: 0x00273390 mscorlibtests`mscorlib_System_Lazy_1_T_REF_get_Value + 128
    frame %17: 0x00e22eb0 mscorlibtests`mscorlibtests1_MonoTests_System_LazyTest_ConcurrentInitialization + 1422
    frame %18: 0x008948e2 mscorlibtests`aot_wrapper_gsharedvt_out_sig_pinvoke_void_this_ + 28
    frame %19: 0x008664a2 mscorlibtests`mscorlib_wrapper_runtime_invoke_object_runtime_invoke_sig_void_intptr_intptr_object_intptr_intptr_intptr + 312
```


Contributes to #13006

Backport of #14400.

/cc @lewurm
2019-05-09 12:06:28 -04:00
Alexander Köplinger 7d5deb616d [sdks] Add .cs source files to ios archive
XI/XM install the Mono sources as part of their package.

(cherry picked from commit a597cee5b0)
2019-05-09 17:25:43 +02:00
monojenkins a0ae702117 A deadlock happens when during a process_suspend there is a pending invoke and then when it's calling the invoke there is another call to process_suspend in the same thread. (#14388) 2019-05-09 10:24:45 -03:00
Alexander Köplinger aee4ff6671 [sdks] Make sure the mono-version.txt directory exists
(cherry picked from commit 8370fe318b)
2019-05-09 11:49:24 +02:00
Alexander Köplinger 30e8a2329b Bump helix-binaries
Helix recently started using Python 3 so we need to have a compatible xunit-reporter.py script.

(cherry picked from commit be571243e4)
2019-05-09 10:40:02 +02:00
Alexander Köplinger 1e96a5cfe6 [sdks] Add Mono version to ios/mac archive 2019-05-08 17:09:10 +02:00
Alexander Köplinger a98c697a6d [sdks] Add Mono binaries to mac archive 2019-05-08 12:45:07 +02:00
monojenkins a5c39e9ac4 [2019-04] [loader] Don't store through a null ptr (#14112)
* [loader] Dont't store through a null ptr

If 'status' is null, don't try to write to it.

Fixes https://github.com/mono/mono/issues/13941

* [metadata] Protect writes to MonoImageOpenStatus* in a few places.

When possible assert that `MonoImageOpenStatus *status` arguments to various
functions in the runtime aren't null.  There are a few places (MONO_API) where
it's possible that callers are passing null.  In that case, use a local
MonoImageOpenStatus, or check for null before doing assignments.
2019-05-07 20:41:23 +02:00
Alexis Christoforides 11e10a07ad [corlib] Fix exception 'replacement' in IsolatedStorageFile.MoveFile()
This was caused by changes in File.Move coming from https://github.com/mono/mono/pull/12000
2019-05-07 14:34:03 -04:00
monojenkins 10db3b9dd0 [debugger-agent] Ignore thread_end event if thread is detached (#14003)
The thread_stopped profiler event can be raised by the thread_info_key_dtor tls
key destructor when the thread is already doesn't have a domain set.  In that
case, don't call process_profiler_event since it cannot handle a thread with
null TLS values.

Addresses https://github.com/xamarin/xamarin-android/issues/2920
with the following stack trace

```
* thread #20, name = 'Filter', stop reason = signal SIGSEGV: invalid address (fault address: 0xbc)
  * frame #0: libmonosgen-2.0.so`mono_class_vtable_checked(domain=0x0000000000000000, klass=0x0000007200230648, error=0x00000071e92f9178) at object.c:1890
    frame #1: libmonosgen-2.0.so`get_current_thread_ptr_for_domain(domain=0x0000000000000000, thread=0x00000071ebfec508) at threads.c:595
    frame #2: libmonosgen-2.0.so`mono_thread_current at threads.c:1939
    frame #3: libmonosgen-2.0.so`process_event(event=<unavailable>, arg=<unavailable>, il_offset=<unavailable>, ctx=<unavailable>, events=<unavailable>, suspend_policy=<unavailable>) at debugger-agent.c:3715
    frame #4: libmonosgen-2.0.so`thread_end [inlined] process_profiler_event(event=EVENT_KIND_THREAD_DEATH, arg=0x00000071ebfec508) at debugger-agent.c:3875
    frame #5: libmonosgen-2.0.so`thread_end(prof=<unavailable>, tid=<unavailable>) at debugger-agent.c:3991
    frame #6: libmonosgen-2.0.so`mono_profiler_raise_thread_stopped(tid=<unavailable>) at profiler-events.h:105
    frame #7: libmonosgen-2.0.so`mono_thread_detach_internal(thread=<unavailable>) at threads.c:979
    frame #8: libmonosgen-2.0.so`thread_detach(info=0x00000071e949a000) at threads.c:3215
    frame #9: libmonosgen-2.0.so`unregister_thread(arg=<unavailable>) at mono-threads.c:544
    frame #10: libmonosgen-2.0.so`thread_info_key_dtor(arg=0x00000071e949a000) at mono-threads.c:774
    frame #11: 0x00000072899c58e8 libc.so`pthread_key_clean_all() + 124
    frame #12: 0x00000072899c5374 libc.so`pthread_exit + 76
    frame #13: 0x00000072899c5264 libc.so`__pthread_start(void*) + 44
    frame #14: 0x000000728996617c libc.so`__start_thread + 72
```
2019-05-07 20:22:46 +02:00
monojenkins 186a3b768e [2019-04] [corlib] Fix a few NSLogWriter issues. (#13952)
* [corlib] Make NSLogWriter thread-safe.

* [corlib] Simplify newline checking in NSLogWriter.

Checking the StringBuilder buffer after writing to it instead of the input
string/char[] makes the code somewhat simpler.

* [corlib] Fix NSLogWriter.Write to take into account the index and count parameters.
2019-05-07 20:21:33 +02:00
monojenkins cd42fa383f [arm] fix armv7k regression on struct passing (#14380)
[2019-04] [arm] fix armv7k regression on struct passing

We can't use `slotsize=8` on `armv7k` as it leads to stack corruption.

Note that `mtouch` already calls the AOT compiler with `--aot=mtriple=arm64_32-ios`, so no changes are required there.

Regression introduced by https://github.com/mono/mono/pull/12992

Fixes https://github.com/mono/mono/issues/13454


Backport of #14362.

/cc @lewurm
2019-05-07 11:37:30 -04:00
Alexander Köplinger 3134b554ed [sdks] Add Mono libraries to mac archive 2019-05-07 17:19:43 +02:00
Alexander Köplinger c716c2200b [sdks] Add mono-2.pc to mac archive
Xamarin.Mac needs it.
2019-05-07 15:59:38 +02:00
Alexander Köplinger 4616c1c2d6 [sdks] Add Mono libraries and frameworks to iOS archive 2019-05-07 15:59:38 +02:00
Alexander Köplinger 6f7e90d908 [sdks] Remove --with-monotouch from configure arguments
They are only needed for BCL builds and those are disabled by --disable-mcs-build
2019-05-07 15:59:38 +02:00
Alexander Köplinger bec31562b2 [sdks] Fix README.md 2019-05-07 15:59:38 +02:00
monojenkins 18b454c267 Bump API snapshot submodule 2019-05-06 15:02:14 +02:00
Marek Safar 5ce3f8f62b [Facades] Include missing enums in System.Memory 2019-05-06 15:02:14 +02:00
Alexander Köplinger 6c135b00e3 [tests] Write nunit/xunit exclude categories to a file (#14281)
So we can include it in the SDKs archive.

(cherry picked from commit 4eea0870e1)
2019-05-06 14:01:19 +02:00
monojenkins 1a105af0bc [arm] amend stack pointer properly in exception trampoline (#14314)
[2019-04] [arm] amend stack pointer properly in exception trampoline

The previous attempt ( https://github.com/mono/mono/pull/14078 ) only fixed it for ABIs where the stack pointer alignment is 8 bytes. ABIs, such as watchOS, require 16 byte alignment.

Fixes https://github.com/mono/mono/issues/14223

Backport of #14310.

/cc @lewurm
2019-05-03 13:56:18 -04:00
Zoltan Varga fd4b429551 [aot] Avoid passing -march=arm to llc when using thumb, it forces arm32 code generation.
Fixes https://github.com/mono/mono/issues/14247.
2019-05-02 15:46:37 +02:00
monojenkins 705aa0209b [2019-04] [corlib] Add API that was dropped during the coreFX System.IO integra… (#14275)
* [corlib] Add API that was dropped during the coreFX System.IO integration

* Bump API snapshot submodule
2019-05-01 14:23:21 -04:00
Jay Krell 9091e89cbf Remove libgcc_s_seh-1.dll dependency when targeting Win32 with gcc. (#14251)
Don't use popcount intrinsic.
Alternative but not exactly contradictory to https://github.com/mono/mono/pull/14248.

Note that this is a single inlinable instruction on x86,
if you assume at least SSE4 from circa 2007, which I am avoiding here.

(cherry picked from commit 90a91429ae)
2019-04-29 16:14:35 +02:00
Alexander Köplinger 64630570f7 [nunit-lite] Use .NOTPARALLEL to possibly fix some races
We're seeing occasional build errors on CI that seem to be some kind
of race when compiling nunit-lite and nunit-lite-console.

(cherry picked from commit c3541fc543)
2019-04-29 14:12:29 +02:00
Vlad Brezae dd06ea25fa [interp] Fix GetFunctionPointer (#14176)
This method returns a function pointer that can be called with a calli instruction. On interpreter we use a pointer to InterpMethod while on jit we use the native code address. Normally, GetFunctionPointer should return the InterpMethod pointer if called from interp or the native code address if called from jit. Since we don't have any information about the execution engine of the caller, we solve this by intrinsifying all these calls, that happen in the interpreter.

Passing such function pointers between jitted and interp code is probably still unreliable.

Fixes https://github.com/mono/mono/issues/13654
2019-04-26 21:10:08 +02:00
monojenkins c1b2d24d3b [2019-04] Fix arm32 tailcall_reg/tailcall_membase. (#14236)
* When moving parameters for tailcall, and having pushed ip, and adjusting the offset to account for that, split the adjustment between sp and frame pointer, as frame pointer may or may not be sp. This fixes https://github.com/mono/mono/issues/11489.

* Revert "[Tailcall] [arm] [jit] Fix moving tailcall parameters. (#12701)"

This reverts commit 257efc6374.
2019-04-26 10:53:21 -04:00
monojenkins b7cc391243 [interp] fix op_explicit for cast from nfloat to nint and vice versa (#14222)
[2019-04] [interp] fix op_explicit for cast from nfloat to nint and vice versa

Fixes https://github.com/xamarin/xamarin-macios/issues/5809

/cc @spouliot 

Backport of #14201.

/cc @lewurm
2019-04-25 05:36:18 -04:00
monojenkins 28a266a434 [2019-04] [interp] Fix interp strmfld vt (#14212)
* [interp] Fix store remote value type field

Looks like the culprit for some random mcs tests failures

* [interp] Delete dummy code
2019-04-25 12:07:08 +03:00
monojenkins f103f5ce57 [2019-04] [acceptance-tests] Run roslyn tests using in-tree mono instead of system mono (#14198)
We were inadvertently running the roslyn tests against the system mono in CI.
Instead we now install mono to a custom prefix, prepend that to PATH and run
the roslyn tests against the correct mono we just built.
2019-04-24 11:30:46 +02:00
monojenkins 525877cfe1 [aot] partial revert of #14043 (#14138)
[2019-04] [aot] partial revert of #14043

We need to emit a real call here. On arm/android we would emit this now:
```asm
ldr pc, =label
.ltorg         # place address of `label` here.
```
which is a jump to `label`, not a call.

We need a different solution to make larger assemblies work, but for now
I revert it so the `2019-02` intergration is unblocked.

Partial revert of #14043


Backport of #14135.

/cc @lewurm
2019-04-23 11:46:27 -04:00
monojenkins 3d2df4c76e [interp] Fix buffer overflow when incrementing sp (#14148)
Fixes https://github.com/mono/mono/issues/14079
2019-04-23 16:46:03 +03:00
monojenkins fc25025f64 [2019-04] Protecting boxing a null value (#14115)
When a static method is called the obj is not used, so it can be null and it doesn't need to be boxed. Adding an assert in the method to prevent other crash in this method if a NULL is received.
2019-04-18 11:39:40 -03:00
Jay Krell 1c08f4db80 Increase gsharedvt trampolines by 10% from 4000 to 4400.
There are many minor arguments here.

Where this matters most -- iOS -- the pool is already dynamic.

Other platforms could use a dynamic pool or JIT (despite FullAOT).
Using JIT would defeat the test coverage.

Mitigates https://github.com/mono/mono/issues/13888.
If this feels too tenative, go bigger.
2019-04-18 14:02:32 +02:00
monojenkins 030986fed7 [2019-04] [aot] change method table generation so that it works for larger assemblies on ARM (#14053)
[2019-04] [aot] change method table generation so that it works for larger assemblies on ARM

At the end of the AOT compilation, we dump a table containing all method
entrypoints using the toolchain linker to resolve the addresses. Previously
we used `bl` for that, however on larger assemblies the offset might
overflow the 24bit immediate (thus, the linker bailing out with
"Error: branch out of range"). Instead, using `ldr pc,=<label>` followed
by `.ltorg` emits the full 32bit address to a method. That takes 8 bytes
for each method instead of 4 bytes.


( I couldn't reopen https://github.com/mono/mono/pull/3486 anymore)

Backport of #14043.

/cc @marek-safar @lewurm
2019-04-16 17:55:54 -04:00
monojenkins 0f956be2e8 [arm] align stack pointer in throw trampoline (#14085)
[2019-04] [arm] align stack pointer in throw trampoline

This is a regression introduced by e46fa20466

Fixes https://github.com/mono/mono/issues/13672

Backport of #14078.

/cc @akoeplinger @lewurm
2019-04-16 16:16:20 -04:00
Alexis Christoforides 68eea797de [MacSDK] Bump F# to 4.5 (#10919) (#14058)
* Use a custom prefix instead of trying to infer it, which doesn't work under bockbuild.

The following line is problematic in the scope of building the Mac SDK package (using bockbuild):

https://github.com/fsharp/fsharp/blob/ccfccbacfdb16b2ab143cf83f5ece20f738fd864/mono/config.make#L5

It's problematic because where `mono` lives in this case would be something like `/macsdk-staging-dir/bin/mono` which is not the actual prefix (prefix here being the final destination, `/Library/Frameworks/Mono.framework/...`) but a staging area that bockbuild uses (this is how we build on system prefixes without installing on CI)

For the F# build, bockbuild expects things to end up  in `/fsharp-staging-dir/$(prefix)` (because that's what most `make install`s do when given `DESTDIR=/fsharp-staging-dir/`). If things end up in _any other_ directory in `/fsharp-staging-dir/`  (like `/fsharp-staging-dir/macsdk-staging-dir` in our case) that would cause us to miss packaging those files (this has happened before, with packages that have broken or different use of `DESTDIR`). So there is an added write-protection for anywhere in `/fsharp-staging-dir` that *isn't*  `/fsharp-staging-dir/$(prefix)` , because a write-protection error, while obtuse, is much preferable to missing the fact that some files are not packaged (as would have happened here)

So the fix is to stop trying to infer the prefix, and return to providing it explicitly to the build system (this used to be the case via the `configure` step)

* Also, if we are doing an override of the 'make' command, we need to take care of passing DESTDIR ourselves too

* Since now we perform 'make install' on the make step, make the 'install' step into a no-operation.

* Look for sn where mono is, not in the final destination (which again, may not be the same)
2019-04-16 09:43:19 -04:00
sancheolz 73430f2f78 [WinForms] Fix displayed image in TreeNode when ImageIndex set to -2 When ImageIndex in TreeNode set to -2 must not displayed any image 2019-04-15 14:26:45 +02:00
Alexander Köplinger c3c1df05ba [corlib] Disable FileTest.SymLinkStats() on TVOS
Symlinks on TVOS run into sandboxing restrictions. We've already disabled a similar test.

This test was added recently as part of 26e0b1deec.

(cherry picked from commit b85fdbdb10)
2019-04-12 14:27:32 +02:00
Maxim Lipnin a184b94276 Remove #if-def for TypedReference.MakeTypedReference readonly restriction 2019-04-12 10:54:24 +02:00
Maxim Lipnin a5c373ff40 [w32error] Add ENONET error case 2019-04-12 08:29:15 +02:00
Zoltan Varga 453c277692 [jit] Make dlmalloc use mono_valloc so it picks up the MAP_JIT flag on osx.
Fixes https://github.com/mono/mono/issues/13878.
2019-04-12 08:28:18 +02:00
Aleksey Kliger 432e2032c9 [utils] stub mono_setmmapjit on Win32 and Wasm 2019-04-12 08:27:34 +02:00
Miguel de Icaza 31efbed2fe Do not use MAP_JIT by default, instead make this something that is toggled by Xamarin.Mac which needs it 2019-04-12 08:27:34 +02:00
Ankit Jain a0d6820d94 [nuget] Bump to nuget 5.0.0 2019-04-11 13:39:15 +02:00
Alexander Köplinger d7431c205e [cil-strip] Fix reading of undefined NativeType values in old Cecil
cil-strip crashed when processing this method: https://github.com/mono/corefx/blob/f54e64b341a7b114c3502e197b46670cacb28639/src/Microsoft.CSharp/tests/DefaultParameterTests.cs#L88

It uses `MarshalAs((UnmanagedType)2000)`, i.e. an undefined value for the
native type. The old Cecil embedded in cil-strip tried to read more than one
byte which blows up in this case. Upstream Cecil just reads a single byte:
https://github.com/jbevain/cecil/blob/1b79b96d29f1e8e9ba832191b1b42ea9cb750d20/Mono.Cecil/AssemblyReader.cs#L3700-L3703

Fixes https://github.com/mono/mono/issues/13639
2019-04-11 13:38:06 +02:00
Alexander Köplinger 342edb8e52 [corlib] Disable a ParameterInfoTest test on MONOTOUCH
It needs SRE and even with interpreter config this doesn't work yet.

(cherry picked from commit 766b3204c3)
2019-04-10 21:00:11 +02:00
Alexander Köplinger aecfd90d2a [configure] Add failsafe for missing submodules (#13957)
GitHub provides a way to download a .zip/.tar.gz of the repository content in their UI, however the archive doesn't contain git submodules.

The mono build then fails with confusing "missing file" errors.

Since GitHub doesn't let us disable the archive download we should at least add some logic to detect this broken case and bail out.

(cherry picked from commit e8caaa1dbd)
2019-04-10 15:26:48 +02:00
Alexander Köplinger 1e53aaa2b3 [System.Net.Http] Make some tests specific to HttpClientHandler
Otherwise they throw PNSE on e.g. WatchOS.

(cherry picked from commit 0b6dbfa349)
2019-04-10 15:03:59 +02:00
monojenkins d9d7943901 [metadata] Don't free_aggregate_modifiers in mono_metadata_free_type (#13796)
The aggregate modifiers container is owned by a MonoImageSet.  The aggregate
modifiers may be shared by more than one MonoType that happen to need the same
modifiers. (Similar to how generic instantiations are shared)

When the image set is cleaned up the aggregate modifier cleanup will free the
types in the aggregate modifiers container (the call to
free_aggregate_modifiers in mono_metadata_clean_for_image).

With this extra call to free_aggregate_modifiers in mono_metadata_free_type may
cause the same memory to be freed twice.

Fixes https://github.com/mono/mono/issues/13775
2019-04-09 18:51:21 -04:00
Bernhard Urban 5fd5f4ab42 [AOT] fix winaot LLVM profile (#13909) (#13944)
[2019-04] [AOT] fix winaot LLVM profile

Regression due to https://github.com/mono/mono/pull/13877

Backport of #13909
2019-04-09 15:05:52 -04:00
monojenkins 5ab8c20e76 [2019-04] [merp] Restore non-assertion behavior in debugger-engine.c (#13932)
In my batch of changes here: https://github.com/mono/mono/commit/c3fe80a0c43be780e35f3a4091d3dc1023b35a00#diff-dca5f20c7ac28a5a4487805c49836fdbL340

I changed

```
			if (!seq_points)
				/* Could be AOT code */
				continue;
```

into

```
			seq_points = (MonoSeqPointInfo *) ji->seq_points;

			if (!seq_points) {
				MonoMethod *jmethod = jinfo_get_method (ji);
				if (jmethod->is_inflated) {
					MonoJitInfo *seq_ji;
					MonoMethod *declaring = mono_method_get_declaring_generic_method (jmethod);
					mono_jit_search_all_backends_for_jit_info (domain, declaring, &seq_ji);
					seq_points = (MonoSeqPointInfo *) seq_ji->seq_points;
				}
			}
```

which doesn't account for the case when it can't find the seq_points. When seq_points is NULL at the end of that block, we don't `continue;` as we did before. Instead we assert, and crash the runtime.

This PR undoes this change, making us continue if `!seq_points`.

Backport of #13865.
2019-04-09 11:29:06 +02:00
Alexander Köplinger 56ce963113 [System.Data] Remove unnecessary file from xunit tests (#13935)
It contained DllImports to some Windows APIs which causes issues on xamarin-macios which expects all pinvokes to exist.

Turns out we don't even need that file.

(cherry picked from commit 3903a50e43)
2019-04-08 23:52:00 +02:00
monojenkins 8d6a92f914 [AOT] remove confusing llcopts flag (#13911)
[2019-04] [AOT] remove confusing llcopts flag

Introduced by
https://github.com/mono/mono/commit/2eeaf888c1d0a681c8705bd609f76196d8fb82ed



Backport of #13877.

/cc @lewurm
2019-04-08 13:56:05 -04:00
Alexander Köplinger b3ff0883cc Bump bockbuild to get GTK fix (#13912)
https://github.com/mono/bockbuild/pull/93
2019-04-08 15:49:13 +02:00
Aleksey Kliger 982adf1ac4 [mono-dl] Don't do thread state transitions in mono_dl_fallback_register
1. it doesn't touch the managed runtime

2. it may be called (arguably it ought to be called only) before the runtime is
initialized (and in particular before the current thread is attached).
2019-04-05 16:04:41 -04:00
monojenkins daf75c61ca [gsharedvt] Fix sizeof opcode (#13832)
[2019-04] [gsharedvt] Fix sizeof opcode

We were setting the stack type by using another global local named ins.

This lead to missing methods in the aot image due to invalid IL. Fixes https://github.com/mono/mono/issues/13479.

Backport of #13817.

/cc @lewurm @BrzVlad
2019-04-04 09:55:23 -04:00
Alexander Köplinger ba238de63b Update csproj file
(cherry picked from commit e75ba60277)
2019-04-04 11:10:15 +02:00
Alexander Köplinger 21e76d610e [corlib] Disable EncodingTest.AllEncodingsAreSerializable() on XM4.5 too
(cherry picked from commit 9eb2dbf4cc)
2019-04-04 01:57:10 +02:00
Alexander Köplinger 84aa2ebf15 [MacSDK] Bump bockbuild for fix to #13804 2019-04-04 00:14:25 +02:00
Alexander Köplinger 4d67a0f9f2 [2019-04] Bump linker to latest master (#13818)
(cherry picked from commit 6717c3422a)
2019-04-03 23:40:32 +02:00
Alexander Köplinger 0796cd6829 [System] Clear MONO_CFG_DIR before starting mcs in CodeDOM CSharpCodeGenerator for XM4.5 (#13742)
* [System] Clear MONO_CFG_DIR before starting mcs in CodeDOM CSharpCodeGenerator

This showed up in the xamarin-macios 2019-02 integration.
When you used Xslt with a custom C# script in a Xamarin.Mac Full application
we'd try to launch mcs via CodeDOM to compile the script.

This started failing in 2019-02 because System.Native (mono-native) wasn't found,
the reason is that XM sets MONO_CFG_DIR to point to the Contents/MonoBundle
in the app bundle where it packages the global config file with dllmaps.

However the started Mono wasn't able to find mono-native since the config
there uses a different name for the file.

To prevent that we now clear MONO_CFG_DIR so it uses the default value for the
mono process we're starting (note that setting it to String.Empty doesn't work)

* Make it specific to XM 4.5

(cherry picked from commit 448cf31a8d)
2019-04-02 10:46:33 +02:00
Jo Shields 2046cf5d26 Fix tarball builds
(cherry picked from commit 262a543a17)
2019-04-01 15:52:05 -04:00
Alexander Köplinger 0f705a4acd Apply API snapshot and csproj changes 2019-04-01 21:51:24 +02:00
Jo Shields f683efc4a6 Merge pull request #13766 from directhex/2019-04
Bump version to 6.2
2019-04-01 11:40:49 -04:00
Jo Shields 7a7bebbfb2 Bump version to 6.2 2019-04-01 10:33:13 -04:00
Filip Navara acb8dd1183 Fix WASM build (#13763)
Broken by https://github.com/mono/mono/pull/13712.
2019-04-01 12:15:50 +02:00
Alexander Köplinger 7c62c3b838 Update API snapshot 2019-04-01 11:33:15 +02:00
monojenkins df0b3ae630 [bcl] Update BCL Linked Size 2019-04-01 08:12:39 +02:00
Marek Habersack acbeffd073 [sdks,mac] Remove dependency on MXE in favor of MinGW
It turns out that homebrew now has a package for the MinGW gcc-based windows
cross compiler which is awesome as it allows us to skip building MXE and use the
latest version of the GCC suite pre-packaged for Mac. This commit removes almost
all traces of MXE (except for `mxe.mk` itself, because I don't know if any bot
or external tool, whatever, use targets in it) and adds the following brew
packages to SDK bot provisioning as well as to the `provision-mxe` target of
Mono SDKs:

  * mingw-w64
  * xamarin/xamarin-android-windeps/mingw-zlib

The latter package builds a Windows version of zlib using MinGW and it comes
from Xamarin's own homebrew tap at https://github.com/xamarin/homebrew-xamarin-android-windeps/blob/f4cc90845ff1953800d8d71035566a12d9b7aa24/mingw-zlib.rb

Additionally, this commit adds a new `configure` flag: `--with-static-zlib=PATH`
which allows one to specify the static zlib archive to use when linking Mono.
The static archive supersedes the otherwise indicated or detected zlib. This is
the recommended mode of operation for MinGW builds as it avoids problems with
`zlib.dll` versions on the target machine.
2019-03-31 11:51:13 -04:00
Filip Navara 9ccfd778e3 [System.Private.CoreLib/mscorlib] Implement Interlocked.MemoryBarrierProcessWide (#13712)
* Implement Interlocked.MemoryBarrierProcessWide

* Bump MONO_CORLIB_VERSION

* Bump API snapshot submodule
2019-03-31 12:08:51 +02:00
Ganbarukamo41 e894d683f9 Implement IEquatable to Memory and ReadOnlyMemory (dotnet/coreclr#23586)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-31 09:51:23 +02:00
Egor Bogatov 282a9635b3 fix IsPinnable 2019-03-31 09:50:09 +02:00
Marcos Cobeña Morián 4747e3c057 Fixed casing (#13736) 2019-03-30 16:53:24 +01:00
Steve MacLean 7ffd5ed8aa Assembly.Load ALC name (dotnet/coreclr#23574)
Use normalized path for ALC name

Signed-off-by: dotnet-bot <[email protected]>
2019-03-30 00:39:00 +01:00
Alexander Köplinger 5cce664b6f Update System.Net.Http for Watch
(cherry picked from commit 4e3ef48ff0)
2019-03-30 00:13:07 +01:00
Alexander Köplinger bb4a72ae3b Bump binary-reference-assemblies
(cherry picked from commit 0366d7da15)
2019-03-29 23:51:52 +01:00
Alexander Köplinger a2462e19e9 [System.Net.Http] Add IVT to Xamarin.* assemblies and update Mac
NSUrlSessionHandler is in Foundation namespace on XM

(cherry picked from commit 5460d8af74)
2019-03-29 23:48:52 +01:00
Marek Safar 4d7931cd0f enable more tests 2019-03-29 23:30:00 +01:00
Marek Safar c302bfdc66 [netcore] Reorder test targets 2019-03-29 23:30:00 +01:00
Marek Safar b3fc4b1263 [System.Private.CoreLib] Adopt delegate to netcore 2019-03-29 23:30:00 +01:00
Marek Safar ec0618dd9e [System.Private.CoreLib] Fix the type conflicts with corefx types 2019-03-29 23:30:00 +01:00
Jo Shields 37a4bd4c08 Fix for OpenBSD scope error in https://github.com/mono/mono/pull/13633 2019-03-29 16:54:26 -04:00
Martin Baulig ccb95fc05f [wasm]: Disable managed collation on wasm. (#13684)
* The `SimpleCollator` class now implements a new internal interface `ISimpleCollator`.
  In `CompareInfo`, we reference it by that interface everywhere except `GetCollator ()`,
  so we can `#if`-def it out.

  Later on, we will use the linker to do this dynamically with some sort of conditional,
  but even then the interface is required to limit references to the `SimpleCollator` type
  to one single method.

* Add `Mono.Globalization.Unicode/SimpleCollator.cs` to `wasm_corlib.dll.exclude.sources`.

* `corlib/Makefile`: remove collation resources on WASM.

* Added new `[Category ("ManagedCollator")]` to the relevant tests.
2019-03-29 21:31:17 +01:00
Aleksey Kliger (λgeek) 20b523ee9c [arm] Don't use C++ keyword as a variable name (#13744)
Fixes the nightly C++ Jenkins jobs
https://jenkins.mono-project.com/job/test-mono-mainline-linux-cxx/
2019-03-29 16:27:49 -04:00
Alexander Köplinger 41672cbc74 Bump binary-reference-assemblies 2019-03-29 19:43:24 +01:00
Alexander Köplinger 15a0b97b10 [System.Net.Http] Move Mac/iOS specific HttpMessageHandler's to Xamarin.*.dll (#13746)
* Revert "[System.Net.Http] Move NSUrlSessionHandler from xamarin-macios to mono (#13229)"

This reverts commit 5bf74a9954.

* [System.Net.Http] Move Mac/iOS specific HttpMessageHandler's to Xamarin.*.dll

We decided to move these types into Xamarin products since they can't be
used without the underlying infrastructure anyway.

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-29 19:27:07 +01:00
Jo Shields 9ebf3a834c Merge pull request #13747 from directhex/dependency_tracking_is_hard
Add missing assemblies needed by Roslyn snapshot
2019-03-29 14:03:40 -04:00
Jo Shields ece0f7cc26 Add missing assemblies needed by Roslyn snapshot 2019-03-29 14:03:06 -04:00
Jo Shields fbc7da2a3f Merge pull request #13633 from rfht/master
Fix DNS Name Resolution Failure on OpenBSD (GitHub issue #8168)
2019-03-29 13:27:48 -04:00
Filip Navara a7a225ceaf [netcore] Guard for skipFrames overflow, update test exclusions (#13745)
* [netcore] Guard for skipFrames overflow

* [netcore] Remove Timer tests exclusion

* [netcore] Remove unnecessary null check
2019-03-29 17:53:52 +01:00
Katelyn Gadd 0de947787c Add missing roslyn assemblies to mcs package makefile (#13738)
* Add missing roslyn assemblies to mcs package makefile

* Remove deploy step for dynamic interface methods prototype since current roslyn has DIM

Roslyn picked up some new dependencies that I failed to add to a Makefile containing a list of its dependencies. This may fix some scenarios (not covered by CI) that result in csc and/or msbuild not working.
2019-03-29 16:39:11 +01:00
Koundinya Veluri 3eef668848 Change Timer implementation on Unixes to use only one scheduling thread (#7071)
* Change Timer implementation on Unixes to use only one scheduling thread

- Separated from https://github.com/dotnet/corert/pull/7066

* Address feedback from https://github.com/dotnet/corert/pull/7066

* Remove reference to s_lock

* Reduce work inside lock

* Move _id

* Fix duplicate timers in scheduled timer list, move info to TimerQueue

Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 15:21:46 +01:00
Egor Bogatov 8cce577994 Update tests 2019-03-29 14:56:22 +01:00
Filip Navara 7ea8460025 Make the DnsTest more resilient to multi-IP DNS results (#13737)
Sometimes Google DNS is/was returning "dns.google" for reverse query of 8.8.8.8 and 8.8.4.4 instead of the expected "google-public-dns-a.google.com" and "google-public-dns-b.google.com". Since "dns.google" resolves to both 8.8.8.8 and 8.8.4.4 in random order the round-trip tests for IP -> hostname -> IP were failing when they got the other IP.

This changes the logic in the hostname -> IP check to check whether the expected IP is any one of the returned ones (ie. non necessarily the first one).
2019-03-29 14:54:49 +01:00
Tanner Gooding 40532637b9 Updating BuildTools, CoreCLR to preview4-03828-01, preview4-27528-71, respectively (#23536)
* Removing FeedTasksPackageVersion from dependencies.props
* The corresponding metadata was removed in https://github.com/dotnet/coreclr/pull/22884

* Updating BuildTools, CoreCLR to preview4-03828-01, preview4-27528-71, respectively

* Adding a ! in String.Searching.cs

Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 14:46:41 +01:00
Zoltan Varga 77e99d080d [netcore] Ongoing work. (#13731) 2019-03-29 12:47:16 +01:00
Ben Adams 20c9bdc20a Avoid boxing allocations for async in Tier0 (dotnet/coreclr#22984)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 08:04:23 +01:00
Marek Safar afb35526cf Simplify StackFrame class (dotnet/coreclr#23483)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 08:04:23 +01:00
Jan Kotas 9d354a7332 Delete RuntimeThread.cs (dotnet/coreclr#23532)
No longer needed

Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 08:04:23 +01:00
Levi Broderick e2c52c86d3 Improve performance of Marvin32 (dotnet/coreclr#22816)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 08:04:23 +01:00
Sung Yoon Whang 419b334239 Fix increment calculation in IncrementingPollingCounter (#23502)
* Add test for IncrementingPollingCounter

* Fix a bug in Increment calculation in IncrementingPollingCounter

* Remove setting DisplayName property since that's a private property for now

* fix comment

* Remove unused variables

Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 07:56:07 +01:00
Santiago Fernandez Madero cbf08f3dd6 Nullable: System.Object (dotnet/coreclr#23466)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 20:17:41 +01:00
Krzysztof Wicher b2e00ef754 Nullable: all calendars (dotnet/coreclr#23469)
* calendar

* nullable: all calendars

* fix likely corert error

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 20:17:41 +01:00
Santiago Fernandez Madero bc096b344f Nullable: System.Char (dotnet/coreclr#23480)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 20:17:41 +01:00
Egor Bogatov 2522547cd5 [netcore] Improve xtest command (#13703)
The python script now also extracts downloaded zips and `make xtest-%` is now able to consume these artifacts.
E.g.
```
make xtest-System.Collections.Tests COREFX_ROOT=/prj/corefx-repo
```
We still need COREFX_ROOT because of two missing files:
`CoreFx.Private.TestUtilities.dll` and `xunit.console.deps.json`
maybe I should just add them to our repo?

Also this PR fixes `RemoteExecutorConsoleApp` problems for `make xtest-%`
2019-03-28 18:00:34 +01:00
Larry Ewing 49ba9f32ec Merge pull request #13705 from kjpou1/wasm-issue-12871
[wasm] Fix System.DllNotFoundException: libc
2019-03-28 11:44:43 -05:00
Alexander Köplinger f48b0a70c3 [Mono.Runtime.Tests] Remove duplicate file in .sources 2019-03-28 16:40:07 +01:00
simplejackcoder e3471b915d GetPinnableReference on String.cs (dotnet/coreclr#23428)
* GetPinnableReference on String.cs

* Add attributes for debugger and performance

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 16:31:00 +01:00
Jo Shields 7e99ce2960 Merge pull request #13700 from directhex/compress-with-xz
Switch `make dist` format from BZip2 to XZ.
2019-03-28 11:22:09 -04:00
Radek Doulik 4cf13bcd16 [profiler] Add duration=NUM parameter to AOT profiler (#13688)
* [profiler] Add duration=NUM parameter to AOT profiler

It instructs the AOT profiler to write the data after NUM seconds
measured from runtime initialization.

* [profilers] Added aot:duration=NUM parameter description
2019-03-28 10:54:36 -04:00
Alexander Köplinger c6b066a7ab Bump corefx to get unit test reliability fix (#13709) 2019-03-28 15:46:21 +01:00
Jo Shields ac0f7ece35 Merge pull request #13699 from directhex/no-more-monograph
Delete monograph. Closes https://github.com/mono/mono/issues/7845
2019-03-28 10:18:53 -04:00
Maxim Lipnin 03e3608b87 Move checks for empty command text to SqlCommand 2019-03-28 15:02:24 +01:00
Maxim Lipnin b1a0ee371a Throw ArgumentException if there is no active statement during reading a row 2019-03-28 15:02:24 +01:00
Filip Navara 8f99674718 Update Makefile 2019-03-28 14:36:07 +01:00
Filip Navara 141493c473 Separate out common code from pinvoke_probe_for_module_relative_directories into pinvoke_probe_for_module_in_directory 2019-03-28 14:36:07 +01:00
Filip Navara 4648210f3b [netcore] Move P/Invoke directory lookup from mono_dl_fallback to pinvoke_probe_for_module_relative_directories 2019-03-28 14:36:07 +01:00
Filip NavaraandAleksey Kliger 3e05b4ea77 [netcore] Handle NATIVE_DLL_SEARCH_DIRECTORIES for p/invoke
Co-authored-by: Aleksey Kliger <[email protected]>
2019-03-28 14:36:07 +01:00
Jan Kotas 8bad65acb8 Move QueryPerformanceCounter PInvokes to shared (dotnet/corefx#36409)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
buyaa-n e76b69f37b Nullable updates for byte type (dotnet/coreclr#23460)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
buyaa-n 1feba9a019 Nullable changes for boolean type (dotnet/coreclr#23451)
* Nullable changes for boolean type

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Santiago Fernandez Madero 6b79fcecc8 Nullable: String (dotnet/coreclr#23450)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Krzysztof Wicher 6ac3ca34e7 nullable: number (dotnet/coreclr#23454)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Krzysztof Wicher c0f4d63fa0 Nullable: Uint32, (U)Int16, (U)Int64 (dotnet/coreclr#23449)
* Nullable: UInt32

* (U)Int16, (U)Int64

* Make NumberFormatInfo non-nullable

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Krzysztof Wicher 23b6018c77 Nullable: Int32 (dotnet/coreclr#23443)
* Nullable: Int32

* remove restore and move nullable up front

* remove trailing \n after #nullable to make it easier to remove later

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Steve MacLean dae859e9e2 ALC Enhancement nits (dotnet/coreclr#23506)
isCollectible default should be false
String should be string

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Steve MacLean ea3b4ae05f ALC enhancements (dotnet/coreclr#22273)
* Initial implementatation of ALC enhancements

Add public constructor with name
Add Name property
Add Assemblies property
Add All property
Override ToString
Name Default and Assembly.Load(...) ALCs
Add AssemblyLoadContext30Extensions test

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:02:28 +01:00
Vlad Brezae 23aa609af7 [interp] Small changes (#13691)
* [interp] Extract the code pushing lmf in separate function

There is no reason to not optimize the code inside do_icall

* [interp] Remove dead code

Trace ips are filled in mono_handle_exception_internal
2019-03-28 13:12:17 +01:00
Zoltan Varga 34f3b8947c [llvm] Fix the computation of size of gshared instances in another place.
Fixes https://github.com/mono/mono/issues/13610.
2019-03-28 13:07:45 +01:00
Filip Navara d261a9ace1 [netcore] Implement missing functions in RegisteredWaitHandle and EventWaitHandle 2019-03-28 08:30:20 +01:00
Jay Krell 83acc1a343 Restore domain in error path. (#13662)
* In mono_threadpool_enqueue_work_item, if mono_runtime_invoke_checked fails,
still restore domain.

In mono_threadpool_enqueue_work_item, acknowledge with a comment but do not change
that mono_domain_set failing leads to returning success.

In mono_threadpool_enqueue_work_item, refactor for sharing code without loss
of efficiency or hopefully clarity.

* Keep this line duplicated:
`mono_runtime_invoke_checked (unsafe_queue_custom_work_item_method, NULL, args, error);`
2019-03-28 02:20:53 -04:00
Jay Krell 3fae397cce Cleanup mono_marshal_get_icall_wrapper (#13661)
Every caller was consistently forming the same name based on callinfo->name
and passing callinfo->func and callinfo->sig.
Pass callinfo instead and do the common work in mono_marshal_get_icall_wrapper.

This has the following side effects:
 Do not form and free name when there is a cache hit. This seems like a nice optimization.
 Allow name when there is a cache hit. This is unintended. We could assert if it is a problem.
2019-03-28 02:20:35 -04:00
Kenneth Pouncey 4904dac430 [wasm] Fix System.DllNotFoundException: libc
Fixes issue: https://github.com/mono/mono/issues/12871
2019-03-28 06:42:10 +01:00
Zoltan Varga 5433bd030e [runtime] Revert daf92b9e62. (#13696)
Fixes https://github.com/mono/mono/issues/13607.
2019-03-27 23:46:43 +01:00
Jo Shields a9c340a063 Switch make dist format from BZip2 to XZ.
Closes https://github.com/mono/mono/issues/9267
2019-03-27 15:50:25 -04:00
Jo Shields 38fdb39cac Delete monograph. Closes https://github.com/mono/mono/issues/7845 2019-03-27 15:45:06 -04:00
Alexander Köplinger 77cf4cc4f8 [tests] Remove MONOMAC ifdef from BCL tests (#13694)
It was set by xamarin-macios when they were still taking the raw .cs source files
but since we switched to prebuilt binaries we need to replace it with
some define we're actually setting in Mono.

Most cases can be replaced by just XAMMAC_4_5 since MOBILE is defined on the xammac profile.
2019-03-27 20:21:48 +01:00
Jo Shields e40d76cb4a Merge pull request #13673 from directhex/runtime-nupkg
Runtime nupkg generation
2019-03-27 14:39:17 -04:00
Alexander Köplinger e8c660ce90 [mono] Don't try "open" handlers on iOS/Android in ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (#13693)
When you use `Process.Start()` with `UseShellExecute=true` (which is the default on Mono/.NET Framework, but false on .NET Core) then we'd still try to first start the file directly, before falling back to trying the "open" handlers like xdg-open to launch the file.

Presumably we do this so that on mobile you can still start a process without needing to explicitly set `UseShellExecute=false`.

However we don't need to try the fallback on iOS/Android since the "open" handlers won't work there anyway.

This recently showed up on the Xamarin.iOS Mono 2019-02 integration where we started running the `System.Diagnostics.ProcessTest` suite and the `Start1_FileName_NotFound()` would fail at `#C6` because the native error code wasn't 2 (file not found) but 13 (invalid data). This is because it tried
to use `/usr/bin/open` which doesn't work of course so it got to the `mono_w32error_set_last (ERROR_INVALID_DATA)` on L2088.
2019-03-27 19:11:48 +01:00
Jo Shields a48e2c8e10 Add some RID detection, and use it to allow runtime nupkg generation
We cannot presume more than just "linux" or "osx" in our RIDs, because
if we want to enable --host vs --build, we can't detect the OS from
the runtime environment.

This is an okay compromise for now.
2019-03-27 10:28:50 -04:00
Jo Shields 7f04ffa847 Add possibility of generating a runtime .nupkg for Mono (Mac-only right now) 2019-03-27 10:28:50 -04:00
Filip Navara 7a74f15949 [netcore] Fix stack size for new threads 2019-03-27 15:23:59 +01:00
Marek Safar fdc4920d5f [System.Private.CoreLib] Implement exceptions capturing 2019-03-27 15:22:50 +01:00
Maxim Lipnin a9f3b8ca54 Port 13553 "Fix transition offset logic" to master 2019-03-27 14:57:03 +01:00
Filip Navara c45f622d97 [netcore] Fix thread debugging messages 2019-03-27 14:33:54 +01:00
Tanner Gooding e658a7d478 Cleaning up the P/Invoke signatures for QPF and QPC to avoid marshalling and pinning (#36071)
* Cleaning up the P/Invoke signatures for QPF and QPC to avoid marshalling and pinning

* Responding to PR feedback.

* Dropping support for low resolution stopwatch

* Removing BestFitMapping=false

* Removing unneeded unsafe declarations

* Addressing more PR feedback

* Fixing the pal_time header file

* Fixing the Unix P/Invoke signatures for GetTimestamp and GetTimestampResolution to return ulong.

* Fixing GetTimestampResolution to scale the result for HAVE_CLOCK_MONOTONIC

Signed-off-by: dotnet-bot <[email protected]>
2019-03-27 14:32:40 +01:00
lateralusX b98013086e Fix incorrect use of FreeHGlobal on Marshal UTF8 allocated string. 2019-03-27 14:23:44 +01:00
Zoltan Varga c7d6919ceb [netcore] Download test assets from the dotnet-core blob feed. 2019-03-27 14:22:41 +01:00
sancheolz a68389fe9a Fix NRE when combobox was disposed and Text set (#13665)
If combobox already was disposed and we setting Text field there will be NullReferenceException. On .net winforms there no excetions.
2019-03-27 13:02:56 +01:00
Alexander Köplinger 1bc213fac1 [System.Xml] Don't hardcode nunit-lite-console in GeneratedCodeAttribute
Instead determine it at runtime.
2019-03-27 11:39:22 +01:00
Alexander Köplinger 5602acf399 [corlib] Skip FileTest.LastWriteTimeSubMsCopy on older iOS Simulators (#13681)
When we switched to using the corefx System.IO.File implementation we also switched to an implementation that uses the `copyfile()` standard library call on macOS/iOS to copy files. This should preserve file metadata such as timestamps.

However there's a small edge case: when using an older version of the iOS Simulator < 11.0 the `copyfile()` call doesn't copy sub-second timestamps, presumably because older iOS ran on HFS which doesn't support that.
When we run this simulator on modern macOS which uses APFS and thus supports sub-second timestamps the origin file used for the test _does_ have sub-second timestamps and the test would fail.

We now skip the test in such environments.

PS: why did this not fail with the old Mono implementation? We used to always call utimes() on the destination file after copying to copy metadata, which in turn would update the file in the simulator host.
It doesn't seem worth it to replicate that behavior for this small edge case.
2019-03-27 11:26:16 +01:00
Katelyn Gadd e9d847d0f6 Bump roslyn binaries to 3.1.0 and add VBCSCompiler.exe to the set of paths auto-detected by configure.ac (#13518)
* Reconfigure bump for PR test

* Actually bump submodule this time probably

* Bump submodule

* Revert "Bump submodule"

This reverts commit b47679be10d3c38d40673cf73e0dc48a300318bc.

* Bump submodule

* Modify csi-test.csx to manually reference netstandard 2.0, because this is required for some reason

* Checkpoint: Test modifying csi.rsp instead of csi-test

* Git

* Update submodule

* Update submodule compiler path

* Remove binaries-new submodule

* Update to latest roslyn-binaries revision and update path in configure.ac
2019-03-27 09:17:24 +01:00
Zoltan Varga 4bb8637454 [netcore] Fix some thread failures. 2019-03-27 09:15:45 +01:00
Zoltan Varga de89d6dc77 [netcore] Fix ArgumentException argument order. 2019-03-27 09:15:45 +01:00
Zoltan Varga 593853ef06 [netcore] Disable boehm. 2019-03-27 09:15:45 +01:00
Martin Baulig 1af992a5ff Split AppDomain.DoTypeResolve(object) into DoTypeResolve() and DoTypeBuilderResolve(). (#13142)
* Instead of having one `AppDomain.DoTypeResolve(object)` that checks at runtime whether
  the argument is a `string` or a `TypeBuilder`, use two strongly-typed methods
  `DoTypeResolve(string)` and `DoTypeBuilderResolve(TypeBuilder)`.

* Add both to the `corlib/LinkerDescriptor/mscorlib.xml`.

* Adjust the code in `appdomain.c` accordingly.

* Bump corlib version.

This is part of a larger on-going project to improve the linker logic.

The rationale behind this is that the new `AppDomain.DoTypeResolve(string)`
that is being called from `mono_domain_try_type_resolve_name()` should not
reference `TypeBuilder`, to allow the linker to remove some of the
`System.Reflection.Emit` types.
2019-03-27 01:51:38 -04:00
Jay Krell 636160148f Cleanup double semi-colons. (#13660)
Cleanup double semi-colons.
2019-03-26 23:45:42 -04:00
Filip Navara fea837d6d3 Fix sample path 2019-03-26 20:47:21 +01:00
Filip Navara b9b6923a58 Exception stack trace should be null when not thrown yet 2019-03-26 20:47:21 +01:00
Marek Safar 06cdc67e2f [System.Private.CoreLib] Implement StackTrace construction from current thread 2019-03-26 19:52:00 +01:00
Egor Bogatov 2f1c1d3b2c [netcore] Implement Array.Sort (#13674)
* Update Array.cs

* implement Array.Sort
2019-03-26 18:10:23 +01:00
Martin Baulig 22073ed676 Cosmetic: remove accidentally added gensources debugging flag. (#13678) 2019-03-26 18:02:55 +01:00
Bernhard Urban 5e70d5ee51 [intrinsics] sync implementation with IL code (#13647)
* [intrinsics] sync implementation with IL code

Before the intrinsic implemented
```
ldarg.0
ldarg.1
sizeof !!T
mul
conv.i
add
ret
```

now it implements
```
ldarg.0
ldarg.1
sizeof !!T
conv.i
mul
add
ret
```

`conv.i` and `mul` have been swapped. Also see https://github.com/mono/mono/pull/13609

* fix op_sext_i4 usage
2019-03-26 12:30:18 -04:00
Zoltan Varga 9d652a972a [llvm] Fix the computation of size of gshared instances in emit_args_to_vtype (). (#13659)
Fixes https://github.com/mono/mono/issues/13610.
2019-03-26 16:28:59 +01:00
Filip Navara e7011c780f Convert from ucontext_t (or platform equivalent) to MonoContext early and propagate it through 2019-03-26 10:56:49 +01:00
Filip Navara 69abf8f5e4 Preserve the native crash context instead of MonoContext to allow printing managed stack trace later 2019-03-26 10:56:49 +01:00
Filip Navara d8e53c515d [netcore] Change loader behaviour to disable assembly remapping and allow loading newer assembly versions 2019-03-26 09:03:04 +01:00
Marek Safar 86506fbdbd [System.Private.CoreLib] Implement StackFrame initialization 2019-03-26 08:39:15 +01:00
Larry Ewing ed2d3504d6 Merge pull request #13620 from kjpou1/wasm-misc-cleanup
[wasm] Remove specific link to framework file when building test-suite
2019-03-25 13:55:51 -05:00
Bernhard Urban 64e17113b2 [amd64] use 32bit variant of lea_membase for 32bit operations (#13642)
[amd64] use 32bit variant of lea_membase for 32bit operations

Consider
```
 xor %r15, %r15       // %r15 = 0x0
 dec %r15d            // %r15 = 0xffff_ffff
 lea 0x1(%r15), %rdx  // %rdx = 0x1_0000_0000 but should be 0x0
```

instead `lea 0x1(%r15), %edx` should be generated.


Fixes #13452
Fixes #13597
2019-03-25 14:25:43 -04:00
Larry Ewing 05a40c67ea Merge pull request #13636 from kjpou1/wasm-add-bindings
[wasm] [packager] Remove the unnecessary call to add_bindings()
2019-03-25 12:13:01 -05:00
Egor Bogatov e653d48b3a [netcore] Improve xunit console runner (#13648)
* improve xunit runner

* improve xunit runner
2019-03-25 16:40:42 +01:00
Larry Ewing 478656ff1d Merge pull request #13416 from kjpou1/wasm-websocket-tests
[wasm][tests] Add WebSocket tests
2019-03-25 09:12:29 -05:00
Zoltan Varga 1fb3b3b87d [netcore] Add System.Reflection.Emit support. (#13613) 2019-03-25 15:04:36 +01:00
Marek Safar 48b8f5ce47 Revert "Do not use MAP_JIT by default, instead make this something that is toggled by Xamarin.Mac which needs it"
This reverts commit a4c8606767.
2019-03-25 14:56:41 +01:00
Johan Lorensson cae256c3b0 Merge pull request #13571 from lateralusX/lateralusX/add-utc-timezone-on-fallback
Add UTC timezone in WinRT GetSystemTimeZones fallback implementation.
2019-03-25 09:30:47 -04:00
Jay Krell 8feaad70f0 Remove const on struct fields. (#13624)
It is unusual and not useful.
2019-03-25 08:36:38 -04:00
Miguel de Icaza a4c8606767 Do not use MAP_JIT by default, instead make this something that is toggled by Xamarin.Mac which needs it 2019-03-25 12:00:41 +01:00
Johan Lorensson 1ff137d950 Merge pull request #13572 from lateralusX/lateralusX/change-test-spincount
Increase spin-count on test to not end up in frequent sleeps on multicore machines.
2019-03-25 06:48:41 -04:00
Kenneth Pouncey 85d86d2215 [wasm] Remove the unnecessary call to add_bindings() when runtime.js is generated. 2019-03-25 11:38:28 +01:00
Jay Krell 004314e9dd [windows]Fix and cleanup configure.ac parsing for MONO_CORLIB_VERSION and ACINIT. (#13630)
Not just a guid or an uppercase guid.
2019-03-25 10:55:15 +01:00
Bernhard Urban eb1cb188a6 [interp] fix "This greater-than-or-equal-to-zero comparison of an unsigned value is always true" reported by Coverity (#13625)
[interp] fix "This greater-than-or-equal-to-zero comparison of an unsigned value is always true" reported by Coverity
2019-03-25 05:45:59 -04:00
Egor Bogatov ac2fb76ed0 [netcore] Marshal.IsPinnable (#13628)
Needed for MSBuild.
Stream changes were copied from [CoreRT](https://github.com/dotnet/corert/blob/master/src/System.Private.CoreLib/src/System/IO/Stream.CoreRT.cs).
IsPinnable - perhaps it should be an icall/intrinsics for better perf?
[CoreCLR impl for IsPinnable (InternalCall)](https://github.com/dotnet/coreclr/blob/1f3f474a13bdde1c5fecdf8cd9ce525dbe5df000/src/vm/marshalnative.cpp#L257)
[CoreRT impl for IsPinnable](https://github.com/dotnet/corert/blob/master/src/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.cs#L114) (and [MightBeBlittable](https://github.com/dotnet/corert/blob/master/src/System.Private.CoreLib/src/System/Runtime/InteropServices/InteropExtensions.cs#L60))
2019-03-25 10:22:54 +01:00
Nick Schonning 47cc95bbb6 typo: Double word "both" (dotnet/corefx#36272)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 65b123d5e9 typo: Double word "never" (dotnet/corefx#36300)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning f1bde8bbaa typo: Double word "to" (dotnet/corefx#36264)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 659cf556ef typo: Double word "that" (dotnet/corefx#36269)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 83133240dc typo: Double word "a" (dotnet/corefx#36271)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 2a659f1cda typo: Double word "in" (dotnet/corefx#36270)
* typo: Double word "in"

* Update src/System.Console/src/System/Console.cs

Co-Authored-By: nschonni <[email protected]>

Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 0f3c093b09 typo: Double word "the" (dotnet/corefx#36274)
* typo: Double word "the"

* Apply suggestions from code review

Co-Authored-By: nschonni <[email protected]>

Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 0719b0209c typo: Double word "this" (dotnet/corefx#36273)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 4b2c08e01b typo: Double word "are" (dotnet/corefx#36275)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 42199a6297 typo: Double word "types" (dotnet/corefx#36276)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 84bc77cabf typo: Double word "is" (dotnet/corefx#36283)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 32c4104e44 typo: Double word "we" (dotnet/corefx#36288)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Egor Bogatov b3287d7157 [netcore] Semaphore (#13627)
* Update Semaphore.cs

* netcore Semaphore

* Update Semaphore.cs
2019-03-25 08:51:52 +01:00
Nick Schonning 21b1ee3b62 typo: Double word "as" (dotnet/corefx#36277)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 08:34:52 +01:00
Jay Krell fd1baed2af Remove the parsing, hashing, locking, allocations associated with JIT icall signatures. (#13579)
* Remove the parsing, hashing, locking, allocations associated with JIT icall signatures.
Make them statically allocated, single-instanced at compile time, and almost
statically initialized.

Fix C++ and x86.

More x86 fix.

Fix ARMv5.

Undo tedious work to be redone instead of merged from old.

Put all signatures back, prepare for automated conversion.

Replace all the register_icall strings with:

my @a = ("double double",
"long long long",
"long long int32",
"double double double",
"ulong float",
"ulong double",
"long float",
"double int32",
"float float float",
"long double",
"object ptr int int32",
"double ptr",
"int int int ptr ptr ptr",
"int obj ptr",
"int obj",
"int ptr int int ptr object",
"int32 double",
"int32 int32 int32",
"int32 int32 ptr",
"int32 obj",
"int32 object ptr ptr ptr",
"int32 object",
"int32 ptr ptr ptr ptr ptr int32",
"int32 ptr ptr",
"obj ptr int",
"obj ptr",
"object int object object",
"object int object",
"object int",
"object int32",
"object object ptr ptr",
"object object ptr",
"object object",
"object ptr int int int int",
"object ptr int int int",
"object ptr int int",
"object ptr int ptr",
"object ptr int",
"object ptr int32",
"object ptr ptr int32",
"object ptr ptr ptr ptr ptr",
"object ptr ptr",
"object ptr",
"object",
"ptr int",
"ptr obj",
"ptr object int ptr ptr",
"ptr object int32 int32",
"ptr object ptr ptr",
"ptr object ptr",
"ptr object",
"ptr ptr int ptr",
"ptr ptr int",
"ptr ptr int32",
"ptr ptr ptr ptr",
"ptr ptr ptr",
"ptr ptr",
"ptr",
"uint32 double",
"uint32 ptr int32",
"void double ptr",
"void int",
"void int32",
"void obj ptr",
"void object object ptr",
"void object object",
"void object ptr int32 int32",
"void object ptr int32",
"void object ptr",
"void object",
"void ptr int int object",
"void ptr int object",
"void ptr int ptr",
"void ptr int",
"void ptr int32",
"void ptr object int32",
"void ptr ptr int",
"void ptr ptr int32",
"void ptr ptr ptr",
"void ptr ptr",
"void ptr",
"void ptr object",
"void",
);

while (my $line = <>)
{
	if ($line =~ /register|mono_create_icall_signature/ && $line =~ /"/)
	{
		for my $from (@a)
		{
			my $to = "mono_icall_sig_$from";
			$to =~ s/ /_/g;
			$to =~ s/"//g;
			$to =~ s/"//g;
			$to =~ s/"//g;
			$line =~ s/\Q"$from"\E/$to/;
		}
	}
	print($line);
}

Remove whitespace from end of line.

Convert the strings to smaller arrays, of chars now,
that are scaled offsets into MonoDefaults, or -1 for ptrref.

Use smaller encoding.

fix merge

cleanup

* Larger representation that handles alignment.

* Try to undo external changel.

* Fix AOT.

* Fix code search and comments

* Restore warning in this PR.

* More ARM signatures.

* Change representation from pointer to offset.
  Use sizeof for the special case ptrref.
Comments. Perhaps too much.
asserts. Perhaps too much.
A little bit more verbose/readable but essentially the same thing otherwise.
 Perhaps too verbose.

* The initializer all-but-must be pointer-sized.
Even if the values fit in much smaller.
Add comments.
On obscure systems size_t is smaller than a pointer so
gsize or uintptr_t is required. Use gsize.

* Spaces before parens.

* PR: Use enum instead of offsetof.
Use may_alias some.
mono builds with -fno-strict-aliasing, but we had recent
aliasing problem (the enum operators with older g++)
and this looks a little hazardous

We could also have a separate integer or array of byte or array of integer or perhaps string
to resolve the aliasing.

integer: 16 values, 8 max -- could just use an int instead of this array business,
but the representation would be full with no room for expansion.
We are not wasting any/much memory here -- maybe one word per the 200 signatures,
because of sloppyness around any_size_array.

Work a little on dealiasing.
Comment some aliases and make obj/object, int/ptr, bool/boolean share values.

* tweak: Compute all the values once and then directly index small local array.

* Adjust comments to new reality.
Add comments explaining aliasing.

* Add casts to attempt to abide by strict aliasing rules.
2019-03-24 23:16:32 -04:00
thfrwn 6d3aa51dd3 Fix DNS Name Resolution Failure on OpenBSD (GitHub issue #8168) 2019-03-24 17:10:22 -07:00
Kenneth Pouncey 5e61de3a2c Modify packager to load the .pdb files for framework packages. (#13608) 2019-03-24 08:33:27 +01:00
リーフストーム 0b58483fa8 Fix handle leak in cominterop (#13536) 2019-03-23 15:15:57 -04:00
Alexander Köplinger d4953f63ca [sdks] Easier labels for pipeline parts 2019-03-23 10:42:42 +01:00
Alexander Köplinger afdf77b053 [sdks] Build Android Linux Mono SDKs package on CI 2019-03-23 10:30:45 +01:00
Levi Broderick 6ddc22cefe Replace slow implementations in ASCIIUtility with fast implementations (#22516)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-23 09:56:52 +01:00
Jérôme Laban 5134c0fec6 Include the corebindings.c in the package output (#13606)
This update restores the ability to use the packager outside of the mono source tree.
2019-03-23 07:11:01 +01:00
Alexander Kyte 0eac33443d [runtime] Add MONO_LLVM_INTERNAL to *get_aot_init_wrapper* marshal funcs (#13611) 2019-03-23 01:36:58 -04:00
Kenneth Pouncey 1b7c7561ab Remove specific link to framework file when building test-suite 2019-03-23 05:32:51 +01:00
Tarek Mahmoud Sayed 612c1b9f42 Apply Optimization in Index.GetOffset suggested by Levi (#23349)
* Apply Optimization in Index.GetOffset suggested by Levi

* Add Comment

* address the feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-03-22 23:30:09 +01:00
Marek Safar 871975de4e Adopt to shared Exception 2019-03-22 23:27:38 +01:00
Marek Safar 7541d7e5fb Move Exception to shared partition (dotnet/coreclr#23361)
* Move Exception to shared partition

* Remove class name caching

* Not useful comments removal

Signed-off-by: dotnet-bot <[email protected]>
2019-03-22 23:27:38 +01:00
Andrew Hoefling 8fe79b4c8e Updated Exception Handling for Collection<T> (dotnet/coreclr#23290)
* Updated Argument Helper param from list->collection since the parameter name is collection

* Updated exception message to use an out of range exception that doesn't explicitly reference a list

* Simplified if statements that verify if the index is out of range

* Updated if logic to be simplified using (uint)

* Updated exception handling to throw ThrowHelper.ThrowArgumentOutOfRange_IndexException() when the ExceptionArgument was 'Index'

Signed-off-by: dotnet-bot <[email protected]>
2019-03-22 23:27:38 +01:00
Thays Grazia 4abc661805 [DIM] Method call of a class that implements a protected nested interface (#13558)
* Unexpected System.MethodAccessException is thrown for a method call of a class that implements a protected interface inside another interface.

```
public interface I1
{
    protected interface T1
    {
        void M1();
    }

    protected class T2
    {}

    protected struct T3
    {}

    protected enum T4
    {
        B
    }
}

class Test1 : I1
{
    static void Main()
    {
        I1.T1 a = new Test2();
        a.M1();
        System.Console.WriteLine(new I1.T2());
        System.Console.WriteLine(new I1.T3());
        System.Console.WriteLine(I1.T4.B);
    }

    class Test2 : I1.T1
    {
        public void M1()
        {
            System.Console.WriteLine("M1");
        }
    }
}
``


Fixing this case Test1 implements I1<int> but can access methods from I1<object>
public interface I1<X>
{
    protected interface T1
    {
        void M1();
    }

    protected class T2
    {}

    protected struct T3
    {}

    protected enum T4
    {
        B
    }
}

class Test1 : I1<int>
{
    static void Main()
    {
        I1<object>.T1 a = new Test2();
        a.M1();
        System.Console.WriteLine(new I1<object>.T2());
        System.Console.WriteLine(new I1<object>.T3());
        System.Console.WriteLine(I1<object>.T4.B);
    }

    class Test2 : I1<object>.T1
    {
        public void M1()
        {
            System.Console.WriteLine("M1");
        }
    }
}
2019-03-22 18:37:16 -03:00
Marek Safar 1a4014dbc0 Move Buffer constants to platform specific files (dotnet/coreclr#23352)
* Move Buffer constants to platform specific files

* Add explicit access modifier

Signed-off-by: dotnet-bot <[email protected]>
2019-03-22 21:57:24 +01:00
Aleksey Kliger (λgeek) d465a7ad65 [aot] cleanup MonoError in add_extra_method_with_depth (#13605)
I missed something in the code review for #13581.  Need to cleanup MonoError if it's not ok.
2019-03-22 21:24:56 +01:00
Egor Bogatov e72d6d9e1c [netcore] Implement missing bits in Mutex (#13591)
Needed for xunit console runner tool.
2019-03-22 18:54:20 +01:00
Zoltan Varga b4f4acc133 [aot] Avoid an assert which can happen in normal usage. (#13581)
Fixes https://github.com/mono/mono/issues/13455.
2019-03-22 16:02:15 +01:00
Alexander Köplinger c8508e56b6 [ci] Build macOS .pkg PR builds on a separate bot (#13600)
This allows us to get faster results.
2019-03-22 15:19:24 +01:00
Alexander Köplinger a766d2e802 Bump linker to latest master (#13594)
* Bump linker to latest master

The linker source were reorganized a little bit, e.g. sources in src/

* [csproj] Update project files
2019-03-22 10:10:08 +01:00
Vlad Brezae 216e4aa405 [interp] Make transform phase more flexible (#13516)
* [interp] Fix instruction length

* [interp] Don't generate directly into linear code stream

Allocate each instruction into the mempool and link them together. At the end of code generation and after all potential optimisation passes, we will compact this code into its final form.

* [interp] Add support for branch relocations

For each branch instruction, we store in its data field the il offset that we are branching to. During the final code generation, we resolve all backward branches and add relocs for forward branches. These relocs are then resolved after all instructions have been emitted in the final code stream.

* [interp] Extract vararg call code in separate instruction

It requires a different instruction size and is extremely rare code.

* [interp] Fix backwards branch with large offset

We were adding an unsigned instead of subtracting.

* [interp] Fix line numbers

For each il offset that generated interpreter instructions we store the native offset, during the compaction phase.

* [interp] Fix seq points

We have to defer SeqPoint data creation during the compact generation phase, because that's when we have native offset information. We add a flags field to the interpreter instruction to store any relevant information coming from the compilation phase.

* [interp] Make verbose logging a bit nicer

We no longer have the native offset during the first IL instruction interation. Maybe we should bring back logging for the IL -> IR mapping during the compaction phase.

* [interp] Remove some dead code
2019-03-22 10:06:10 +02:00
Kenneth Pouncey 31cb0e28a5 Fix indentation to address review comments 2019-03-22 05:13:12 +01:00
Jo Shields 21cfdbe81c Make test runner able to deal with whitespace patterns other than newline (#13587)
Helix wasn't running our runtime tests as expected, because the test runner expected newline-separated tests to run, and we were generating space-separated.

Following "be liberal in what you accept" philosophy, and to prevent this issue in the future, just deal with "whitespace separated" rather than "this specific whitespace and no other"
2019-03-22 00:23:28 +01:00
Alexis Christoforides c803e6f75b Xamarin.Android integration fixes (#13589)
Backport of #12940.

- Disable other failing tests (they are tests that are newly added, not regressions)
- Look for mono_pal_init() directly in the System.Native library
- [configure] Have libmono-native depend on libmono(-sgen) for the Android build
If this is not done, Android is not able to resolve mono symbols that are used in mono-native (e.g. mono_add_internal_call_with_flags), and will refuse to load the library with 'cannot locate symbol' errors
2019-03-22 00:15:08 +01:00
Egor Bogatov 0fc15b168f [netcore] Xunit console runner (#13592)
* xunit console runner

* add more xunit args

* use rsp file
2019-03-21 23:43:48 +01:00
Zoltan Varga 53bef4aec4 [llvmonly] Add gsharedvt in wrappers to calls which could go to the interpreter. (#13548)
[llvmonly] Add gsharedvt in wrappers to calls which could go to the interpreter.

Fixes https://github.com/mono/mono/issues/13463.




<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2019-03-21 15:56:06 -04:00
Vlad Brezae 8423f0e9a0 [interp] Enable compile all debug option also on interp (#13570)
[interp] Enable compile all debug option also on interp
2019-03-21 12:05:48 -04:00
Kenneth Pouncey 2b37e1c0b5 Add tests for send and receive of text and binary messages. 2019-03-21 16:37:36 +01:00
Johan Lorensson 7e8d4303fa Couple of fixes to LLVM AOT compiler on Windows x64. (#13474)
* Enable MSVC objects on LLVM >= 6.00
* Always used PIC relocation-model on Windows x64 due to LLVM problem with
static triggering incorrect ADDR32 relocation entries in 64-bit objects.
* Add CodeView symbol format instead of DWARF for Windows x64.
* Fix LLVM outfile when doing static link to not end up in temp directory.
* Only add /DEFAULTLIB when using MSVC and not doing static compile. For
static compile the needed libraries must be added when objects get's linked
and since the needed libraries are c-runtime libraries, should be transparent
for most applications consuming the object files.
2019-03-21 10:05:01 -04:00
Kenneth Pouncey 6513fffcd7 Add tests for
- Client Close
- Host Close with CloseStatus and CloseStatusDescription filled in from Host.
2019-03-21 14:22:31 +01:00
Bernhard Urban 5852d1cf74 [arm] respect potential spilling for overflow flag check (#13564)
[arm] respect potential spilling for overflow flag check

```
  18 int_sbb R77 <- R54 R57
  19 store_membase_reg [arm_fp + 0x24] <- R77
  20 cond_exc_c OverflowException
```
this wasn't properly handled by the arch lowering pass.

Fixes https://github.com/mono/mono/issues/13284
2019-03-21 08:15:31 -04:00
Nikita Voronchev 037faa47cc [WinForms] Related Forms closing issue (#13150) (#13151)
Fixes #13150
2019-03-21 12:57:55 +01:00
lateralusX b554e0ea2c Increase spin-count on test to not end up in frequent sleeps on multicore machines. 2019-03-21 11:43:55 +01:00
lateralusX 33ea64cf7e Add UTC timezone in WinRT GetSystemTimeZones fallback implementation.
Needed by tests when hitting fallback solution in TimeZoneInfo.WinRT.cs.

Fix also sort the TimeZones similar to how its done in .NET Framework/Core.
2019-03-21 11:38:29 +01:00
Zoltan Varga 6a0a5bf3ca [netcore] Implement/fix enum/nullable comparers. 2019-03-21 11:33:34 +01:00
Zoltan Varga a6dc1cec3b [netcore] Implement RuntimeAssembly.GetSatelliteAssembly (). 2019-03-21 11:33:34 +01:00
Zoltan Varga 622bb8d5d5 [jit] Add JitHelpers.EnumEquals ()/EnumCompareTo () intrinsics. 2019-03-21 11:33:34 +01:00
Egor Bogatov 36a62bbf8a [netcore] Implement missing bits in ThreadPool (#13566)
* implement missing bits in ThreadPool

* remove [SecurityCritical]
2019-03-21 11:29:43 +01:00
Kenneth Pouncey 7dbcf1ed4b Add more tests for websockets. 2019-03-21 11:02:43 +01:00
Kenneth Pouncey a15526af3a [wasm][websockets]Fix Error Code not reported correctly with ClientWebSocket 2019-03-21 11:01:24 +01:00
Jan Kotas f2065c849a Hoist calls to IsBitwiseEquatable (dotnet/coreclr#23381)
Smaller IL is easier for JIT

Signed-off-by: dotnet-bot <[email protected]>
2019-03-21 08:10:47 +01:00
Marek Safar 701ca04b36 Update with shared partition changes 2019-03-21 08:05:14 +01:00
Jan Kotas 48114c0375 Unify EnumInfo and NamesAndValues
Signed-off-by: dotnet-bot <[email protected]>
2019-03-21 08:05:14 +01:00
Alexander Kyte 42c3b73ac1 [merp] Fix anon allocation, use MAP_PRIVATE 2019-03-21 07:48:25 +01:00
Egor Bogatov 8cf878ff50 advanced MemberData support 2019-03-21 07:46:56 +01:00
Bernhard Urban 4111910dd8 [llvm] dump bitcode file even if verifier fails (#13556)
[llvm] dump bitcode file even if verifier fails

This can be useful for debugging issues in the products.
2019-03-20 19:45:39 -04:00
Johan Lorensson d3a2841e93 Adjust genconst to changes in winsetup.bat. (#13554)
When logic moved from winsetup.bat into an msbuild task that changed the
console output of winsetup.bat causing problems for genconst to find
MONO_VERSION and MONO_CORLIB_VERSION. There was also a potential problem
where winsetup.bat couldn't find msbuild.exe if not included in PATH.

This fix makes sure winsetup.bat detect and setup a full msbuild environment
before running msbuild.exe. It also change genconsts to look at the generated
config.h for the correct values of MONO_VERSION and MONO_CORLIB_VERSION that
will be used by the runtime builds.
2019-03-20 18:48:20 -04:00
Bernhard Urban 00d871d103 [ssa] avoid code motion to try-blocks (#13555)
[ssa] avoid code motion to try-blocks

Consider
```
BB4:  // successor BB5, BB9
[...]
br [B9]

BB5: // catch handler block for BB4
[...]
br BB9

BB9:
aotconst R90
gc_safe_point R90
[...]
```

Previously, our invariant code motion pass would move `aotconst R90` to the end of BB4. Unfortunately, BB4 contains instructions that can cause an exception and thus control flow is broken and continues to BB5. `aotconst R90` wouldn't be loaded correctly in this scenario.

When lowered to LLVM IR this is more obvious, and the verification pass of LLVM catches this.

Fixes https://github.com/mono/mono/issues/13460
2019-03-20 18:45:47 -04:00
Thays Grazia 4e13c53451 [dim] System.MethodAccessException is thrown for a protected method declared in an interface (#13513)
* ```
interface I1<T>
{
    sealed protected void M1()
    {
        System.Console.WriteLine("M1");
    }
}

interface I3<T> : I1<T>
{}

interface I2<T> : I3<T>
{
    static void Test(I2<int> x)
    {
        x.M1();
    }
}

class A : I2<int>
{
    static void Main()
    {
        I2<byte>.Test(new A());
    }
}
```
When a interface implements another interface and they are generics, we don't need to check the datatypes of generics, we only need to check the inheritance.
Fixes 13467

* Adding test.

* Using the getter functions

* Initializing klass->interfaces/interfaces_count.

* Update mono/metadata/class.c

Co-Authored-By: thaystg <[email protected]>

* Fixing side effect on dim-simple.il
2019-03-20 18:08:51 -04:00
Aleksey Kliger (λgeek) 60221d88d5 [aot] Fix a few memory leaks (#13514)
1. aot-compiler: don't leak `MonoCustomAttrInfo`

2. aot-runtime: don't leak sigs when decoding wrapper references.  All of these cases we decode a sig (which uses malloc), and then call some method that immediately calls `mini_get_underlying_signature` which dups the sig, so the one from the decode isn't needed anymore.
2019-03-20 16:50:25 +01:00
Alexander Köplinger 242596b243 Bump corefx 2019-03-20 12:10:31 +01:00
Johan Lorensson a0e999549e Merge pull request #13529 from lateralusX/lateralusX/fix-mixup-global-cotask-alloc
Fix mixup of Global Free and CoTaskMem Alloc in Marshal's Secure String implementation.
2019-03-20 05:44:35 -04:00
Egor Bogatov b87bd4f6e4 [netcore] Allow all primitive types to be passed to Buffer.BlockCopy (#13544)
* Update Buffer.cs

* allow all primitive types to be passed to BlockCopy

* convert Len to bytes
2019-03-20 08:41:58 +01:00
Egor Bogatov 8b4eef9387 [netcore] Initial MemberDataAttribute support (#13543)
This PR adds ~2200 tests to System.Runtime.Tests and ~1000 to System.Collections.Tests
2019-03-20 08:40:46 +01:00
Thays Grazia b811e645a3 When it is a sealed method in Interface it's not Static nor Virtual and shouldn't add virtual.
Fixes #13508
2019-03-20 08:36:21 +01:00
Alexander Köplinger 8aaf420efe Fix Windows MSI build 2019-03-20 01:49:26 +01:00
Thays Grazia 86e7400525 [metadata][dim] Unexpected System.NotSupportedException in presence of default interface implementations (#13468)
* namespace Application
{
	public interface I1 { void M1() { System.Console.WriteLine("Unexpected!!!"); }}

	public interface I2 : I1 { void I1.M1() { System.Console.WriteLine("I2.I1.M1"); }}

	public interface I3 : I1 { void I1.M1() { System.Console.WriteLine("I3.I1.M1"); }}

	public interface I4 : I1 { void I1.M1() { System.Console.WriteLine("I4.I1.M1"); }}

	class Test10 : I1, I2, I3, I4 { public void M1() { System.Console.WriteLine("Test10.M1"); } }

	class MainClass {
		public static void Main(string[] args)
		{
			I1 var = new Test10();
			var.M1();
		}
	}
}

The interface method M1 is overridden at I1, at I2, at I3, at I4. The class Test10 overrides method M1 so regardless of having methods overriden in interface, the method of the class should be priority in this case. And then I remove the conflicts because there is not a conflict anymore.
2019-03-19 19:26:09 -03:00
Egor Bogatov 3a2d027e5e fix literals 2019-03-19 23:13:58 +01:00
Sung Yoon Whang dd6a9063c9 Remove timer in RuntimeEventSource (dotnet/coreclr#23311)
* Change RuntimeEventSource's counter types

* cleanup

* cleanup

Signed-off-by: dotnet-bot <[email protected]>
2019-03-19 23:02:11 +01:00
Grant 0584d63bf1 Trim/TrimStart/TrimEnd methods for Memory and Span (dotnet/coreclr#22798)
* Span.Trim

* Add another helper

* Remove redundant comments

* Optimize Trim(ReadOnlySpan<char>)

* Suggested overload for byte

* CR fixes

* CR fix

* Add Span overloads

* Add Memory overloads

* CR

* Rename method

* Optimization

* Tweaks

* Refactor

* Opt

* Use 2 helpers

* CR fixes

* CR fixes

* Nits

* CR fixes

* remove in params

* Bug

* Bug

* Move Trim methods to their own dedicated file

* Add char overloads

* Use Contains

* CR fixes

* Optmize ClampNull

* Nit

* Revert optimization

* Make existing implementations consistent with new

* Revert existing methods

* Move helpers

* Span, Memory and RoM should use consistent pattern

* POC for changing RoS

* Revert POC

* Use consistent idiom

* More inlining of explaining vars

* Use expression body for existing code

* CR fixes

* Nit

* Grammar

* CR fixes

* Fix perf bug in existing code

* Perf fix

* Force CI build

* Force CI

Signed-off-by: dotnet-bot <[email protected]>
2019-03-19 22:29:01 +01:00
Egor Bogatov 2785cdbd30 fix typo 2019-03-19 22:27:50 +01:00
Alexander Köplinger a0f593958b [ci] Fix wrong redirect which would overwrite Make.config 2019-03-19 21:53:40 +01:00
Alexander Köplinger dbc3c1a1cd [sdks] Build mac in Mono SDKs (#13535)
Enables building of the xammac runtime and BCL/tests into the SDKs archive.

Contributes to #11397
2019-03-19 20:44:42 +01:00
Bernhard Urban 4cd5068230 [aot] force v7 on arm when using LLVM on iOS (#13521)
[aot] force v7 on arm when using LLVM on iOS

In https://github.com/mono/mono/pull/11172 we added passing `-march=arm` to `llc`, so that newer LLVM would generate code correctly for the target arch. Unfortunately this seems to break older LLVM, that is still used for 32bit code on Xamarin.iOS. For iOS we need to force it to armv7, otherwise it will try to substitute certain locking primitives with builtins that aren't available as hardware instructions on armv5.


Before this change:

```console
$ nm ./obj/iPhone/Release/mtouch-cache/armv7/mscorlib.dll-llvm.o | grep sync_
         U ___sync_fetch_and_add_4
         U ___sync_lock_test_and_set_4
         U ___sync_synchronize
         U ___sync_val_compare_and_swap_4
00079e1c T _mscorlib_System_Runtime_CompilerServices_AsyncMethodBuilderCore_ThrowAsync_System_Exception_System_Threading_SynchronizationContext
00057f80 T _mscorlib_System_Threading_SemaphoreSlim_WaitAsync_int_System_Threading_CancellationToken
00058430 T _mscorlib_System_Threading_SemaphoreSlim_WaitUntilCountOrTimeoutAsync_System_Threading_SemaphoreSlim_TaskNode_int_System_Threading_CancellationToken
         U _p_1214_plt_mscorlib_System_Threading_SemaphoreSlim_WaitAsync_int_System_Threading_CancellationToken_llvm
         U _p_1217_plt_mscorlib_System_Threading_SemaphoreSlim_WaitUntilCountOrTimeoutAsync_System_Threading_SemaphoreSlim_TaskNode_int_System_Threading_CancellationToken_llvm
         U _p_1735_plt_mscorlib_System_Runtime_CompilerServices_AsyncMethodBuilderCore_ThrowAsync_System_Exception_System_Threading_SynchronizationContext_llvm
         U _p_1976_plt_mscorlib_System_Threading_SemaphoreSlim_WaitAsync_llvm
         U _p_37_plt_mscorlib__jit_icall_ves_icall_thread_finish_async_abort_llvm

```

After this change:

```console
$ nm ./obj/iPhone/Release/mtouch-cache/armv7/mscorlib.dll-llvm.o | grep sync_
0007008c T _mscorlib_System_Runtime_CompilerServices_AsyncMethodBuilderCore_ThrowAsync_System_Exception_System_Threading_SynchronizationContext
00050654 T _mscorlib_System_Threading_SemaphoreSlim_WaitAsync_int_System_Threading_CancellationToken
00050ab4 T _mscorlib_System_Threading_SemaphoreSlim_WaitUntilCountOrTimeoutAsync_System_Threading_SemaphoreSlim_TaskNode_int_System_Threading_CancellationToken
         U _p_1214_plt_mscorlib_System_Threading_SemaphoreSlim_WaitAsync_int_System_Threading_CancellationToken_llvm
         U _p_1217_plt_mscorlib_System_Threading_SemaphoreSlim_WaitUntilCountOrTimeoutAsync_System_Threading_SemaphoreSlim_TaskNode_int_System_Threading_CancellationToken_llvm
         U _p_1735_plt_mscorlib_System_Runtime_CompilerServices_AsyncMethodBuilderCore_ThrowAsync_System_Exception_System_Threading_SynchronizationContext_llvm
         U _p_1976_plt_mscorlib_System_Threading_SemaphoreSlim_WaitAsync_llvm
         U _p_37_plt_mscorlib__jit_icall_ves_icall_thread_finish_async_abort_llvm
```

Fixes https://github.com/mono/mono/issues/13478
2019-03-19 12:46:00 -04:00
Alexander Kyte 04d65f2986 [runtime] Default llvm to self-init+direct native calls (#13312)
* [runtime] Default llvm to self-init

Now the init code is behind llvm_plt_init. Setting
--aot=llvm-plt will bring back the legacy llvm+plt behavior

* [llvm] Mark managed methods no-inline by llvm

* [runtime] Clean up self-disabling machinery

* [llvm] Skip self-init on cctors

* [runtime] Always make ctors call their cctors

* [runtime] Improve mono_print_unwind_info, add cases

* [runtime] Fix too-early eager calling of cctors

We emitted all of the lazy checks and init around a specific static
method, but still were initializing it when we initialized methods
that access it. This made static cctors run before they were supposed
to.

The problem was that the call site here has method == NULL, because
we don't compute it. That's expected, as we don't compute the method
along this path.

This initial "&&" looks like it was supposed to avoid calling the method
on a null MonoMethod reference. This preserves that, while fixing the
control flow issues.

* [runtime] Associate init_method native code with MonoMethod

* [runtime] Future-proof against aot init wrapper subtype mixups

* [runtime] Fix goto in AOT-init change for c++

* [runtime] Move docs for llvm-disable-self-init into runtime

* [runtime] Fix bitcode, remove unneeded wrapper around init icall

* [llvm] Include global prefix in init name

* [comment] Describe debugging usage of llvm self-init disable flag

* [aot] Consolidate mangler string append lines

* [llvm] Make self-init documentation changes

* [llvm] Rename self-init funcs, mini_llvmonly_ to mini_llvm_

* [runtime] Enable inlining for methods without init
2019-03-19 11:13:11 -04:00
lateralusX d4e5d14569 Fix mixup of global and cotask mem alloc heaps in Marshal's Secure String. 2019-03-19 15:53:23 +01:00
Bernhard Urban 6cb5c7f9cf [llvm] fix field init for platforms where unbox_trampolines tables are not used (#13527)
Fixes https://github.com/mono/mono/issues/13522
2019-03-19 15:31:44 +01:00
Kenneth Pouncey d4dec33b84 Merge branch 'master' of https://github.com/mono/mono into wasm-websocket-tests 2019-03-19 14:38:15 +01:00
Zoltan Varga 7a5487b966 [netcore] Ongoing work. (#13509)
* [netcore] Avoid casting to generic parameters in gen-xunit-runner.

* [netcore] Make the build-/run- targets more generic, add support for more test suites.

* remove NIE from Exception

* [netcore] Convert gen-xunit-runner to use roslyn for code generation instead of codedom.

* [netcore] Add check target to run all test suites.
2019-03-19 12:19:33 +01:00
Vsevolod Kukol 8a292ff635 Bump bockbuild to fix Gtk NSView embedding on Mac (#13511)
This fixes mouse event handling for NSViews embedded in Gtk.

Fixes VSTS #802376
Fixes VSTS #821841
2019-03-19 10:23:59 +01:00
Alexander Köplinger 31516f0b3e Reduce number of classes in winaot mscorlib. (#13341)
* Reduce number of classes in winaot mscorlib.

Winaot profile should be a Windows AOT friendly profile close to mobile
and consoles. At some point it was set to include the full net_4_x that
cause problems on none desktop platforms. This fix reduce the set to only
include classes similar to mobile and console profiles.

* Reverting changes to TimeZoneInfo test when reducing classes in corlib winaot.

* Move SafePasswordHandle to win32_build_corlib profile.

* Excluded some additional none Windows sources from win32_build/winaot profile.
2019-03-19 10:07:13 +01:00
monojenkins cecd6b316f [csproj] Update project files 2019-03-19 09:06:36 +00:00
Levi Broderick 909cae3de9 Add Utf8String skeleton (dotnet/coreclr#23209)
Utf8String is an experimental type that is string-like (heap-allocated, immutable, variable-length, null-terminated) but whose inner representation is UTF-8, not UTF-16.

This is a skeleton implementation of the basic API shape. The ecosystem of APIs has not yet been built around it. All Utf8String-related code is currently surrounded by ifdefs to allow easy identification and removal from release branches.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-19 09:44:07 +01:00
Vincent Povirk d21d4764e8 [mono/tests] Fix out of tree build. 2019-03-19 09:40:06 +01:00
Levi Broderick e9e902b929 Add Rune.TryEncodeToUtf8 and related APIs (dotnet/coreclr#23250)
Also renames the existing Encode / Decode APIs per design review feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-03-19 09:33:25 +01:00
Thays Grazia 4fbdcf504d [dim] Interface with sealed method (#13501)
* '''
interface I1
{
   sealed void M1()
   {
       System.Console.WriteLine(“M1”);
   }
}

interface I2 : I1
{
   static void Test<T>(T x) where T : I2
   {
       x.M1();
   }
}

class A : I2
{
   static void Main()
   {
       I2.Test(new A());
   }
}
'''

When an interface implements a Sealed method, this method is not virtual, so it will not be available at vtable. But in the IL the call is a virtual call, but in this case we don't need to search at vtable.

Fixes #13466

* Change IL test.
2019-03-18 18:46:07 -03:00
Johan Lorensson a66f944ff7 Fix a couple of build warnings under MSVC. (#13475) 2019-03-18 14:38:27 -04:00
Alexander Köplinger 9bcad32ca5 Update csproj 2019-03-18 19:30:42 +01:00
Marek Safar b1a155979b Update codeowners (#13505) 2019-03-18 17:32:43 +01:00
Ludovic Henry 1965786397 Update CODEOWNERS 2019-03-18 08:50:19 -07:00
Alexander Kyte f7796b0da0 Merge pull request #13447 from alexanderkyte/fallback_merp_allocator
[crash] Fallback to MAP_ANONYMOUS for allocator
2019-03-18 11:49:52 -04:00
Zoltan Varga d5dfc5e76c [jit] Add RuntimeHelpers:IsBitwiseEquatable () intrinsic. (#13499)
* [jit] Add RuntimeHelpers:IsBitwiseEquatable () intrinsic.

* Update access modifier
2019-03-18 16:33:29 +01:00
Zoltan Varga 5232408f7a [runtime] Avoid putting non-virtual and non-static DIM methods into vtables, roslyn generates these for private property accessors. (#13449)
Fixes part of https://github.com/mono/mono/issues/13374.
2019-03-18 11:54:33 -03:00
Alexander Köplinger 12043bb6f5 [System.Drawing.Common] Enable debug symbols
The facade contains code now so we should build a .pdb.
2019-03-18 15:43:30 +01:00
Zoltan Varga 32b84339cb [netcore] Disable runtime cleanup on netcore, coreclr does not cleanup either. Also disable aborting background threads, its no longer needed. (#13469) 2019-03-18 10:40:22 -04:00
Jay Krell 23999ca43d Cleanup mono_array_new_1, mono_array_new_2, mono_array_new_3, mono_array_new_4.
Mainly to remove the dynamic alloca but also combine common code.
If there is a perf concern then we can forceinline mono_array_new_n.
2019-03-18 15:02:30 +01:00
Alexander Köplinger 5521ad349f [System.Net.Http] Port https://github.com/xamarin/xamarin-macios/pull/5769 to mono 2019-03-18 14:39:54 +01:00
Alexander Köplinger e0326df7c6 More Windows MSI fixes 2019-03-18 13:19:17 +01:00
Alexander Köplinger d431fd5619 Fix nunit-lite signing key 2019-03-18 12:40:38 +01:00
Alexander Köplinger 0ae04b8e80 Fix Windows MSI build, msbuild is now in Current instead of 15.0 2019-03-18 11:40:03 +01:00
Alexander Köplinger 362eface2c Remove more unnecessary nunit24 cruft 2019-03-18 11:31:06 +01:00
Johan Lorensson 273776c737 Merge pull request #13482 from lateralusX/lateralusX/windows-build-script-updates
Windows full AOT build scripts update.
2019-03-18 06:15:42 -04:00
Egor Bogatov 9f25f0f540 cache downloaded net core sdk 2019-03-18 11:15:09 +01:00
Marek Safar 4014060cca Reflect shared code changes 2019-03-18 11:12:40 +01:00
Levi Broderick 9ef79a5156 Make more types eligible for vectorized code paths in MemoryExtensions (#20855)
Types like sbyte, ushort, and other 8-bit / 16-bit elemental types are now directed down the fast vectorized code paths that previously only byte and char were eligible for.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-18 11:12:40 +01:00
monojenkins e52716f9a0 [bcl] Update BCL Linked Size 2019-03-18 11:08:16 +01:00
EgorBo 88acef1575 fix formatting 2019-03-18 10:49:06 +01:00
Egor Bogatov 253753bdb7 Add failing tests 2019-03-18 10:49:06 +01:00
Egor Bogatov 0801bfe4aa fix bug 2019-03-18 10:49:06 +01:00
Egor Bogatov 0d48237457 fix case when InlineData's type != ParameterType 2019-03-18 10:49:06 +01:00
Zoltan Varga 8b9d89b150 [netcore] Fix running tests. (#13493)
* [netcore] Fix running the tests.

* [netcore] Implement missing enum icalls.
2019-03-17 20:55:49 -04:00
Marek Safar fc7ab5076e Adapt shared Enum 2019-03-17 13:42:00 +01:00
Egor Bogatov 5df1bae25d Move Enum and CorElementType to shared (dotnet/coreclr#23177)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-17 13:42:00 +01:00
Sung Yoon Whang bc420a440e Fixing some payload serialization issue on new EventCounters (#23295)
* Fixing some payload serialization issue on new EventCounters

* Fix build error

Signed-off-by: dotnet-bot <[email protected]>
2019-03-17 08:09:21 +01:00
Nikita Potapenko cfa37ea29b Fix typo (dotnet/coreclr#23300)
.Net -> .NET

Signed-off-by: dotnet-bot <[email protected]>
2019-03-16 18:44:58 +01:00
sancheolz 1ca9fcc201 Fix local variable assign
Local variable must be assigned before use
2019-03-16 10:30:49 +01:00
[email protected] f278deee46 Fix Stackoverflow when SplitContainer`s SplitterDistance setted in SplitterMoved event subscription 2019-03-16 10:30:49 +01:00
monojenkins 9522ae42bb [bcl] Update BCL Linked Size 2019-03-16 10:22:50 +01:00
Zoltan Varga a0d0209fb1 [netcore] Add support for running tests.
* Move the sdk download from netcore/sample/Makefile to netcore/Makefile
* Add targets for running the System.Runtime.Tests test suite.
2019-03-16 10:20:51 +01:00
Jay Krell d34b6da0d8 [Coop] Convert ves_icall_System_Globalization_CultureData_fill_number_data. (#13477)
* [Coop] Convert ves_icall_System_Globalization_CultureData_fill_number_data.

Tested by running this program:
```
class A
{
	public static void Main()
	{
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.CompareInfo);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.DateTimeFormat.AMDesignator);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.DateTimeFormat.DateSeparator);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.DisplayName);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.EnglishName);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.IsNeutralCulture);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.IsReadOnly);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.LCID);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.Name);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.NativeName);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.NumberFormat.CurrencySymbol);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.NumberFormat.NumberDecimalDigits);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.NumberFormat.NumberDecimalSeparator);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.Parent);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.TextInfo);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.ThreeLetterISOLanguageName);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.ThreeLetterWindowsLanguageName);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
	}
}
```

which covers some but not all of the data.

*  - Use gint32 instead of int when interfacing directly with managed code.
   Indirectly would be passing the parameter off to additional native code; compiler
   can often silently convert.
   int will always be 32 bits.

 - Expand tedious error-prone code instead of using preprocessor to automate.

 - Add comments that the native and managed types must match.

 - Rename the managed type to match the native type (not necessary,
   but might as well have them grep perfectly coincidentally.).

 - Sort the fields and some of their uses for easier reading.
 It might be infinitesimally faster to line up the order
 with the native structure, to synchronize access order (i.e. sequential access to all).

 - Restore parameter name to number_index.

 - Validate, with assert, number_index maximum not just minimum.

* Restore the group_sizes logic.
group_sizes is an array of up to two integers, -1 terminated.

* restore const

* Add comment explaining the ordered -- sorted alphabetically.
2019-03-15 16:56:41 -04:00
Larry Ewing e61f00cd2d Merge pull request #12984 from kjpou1/wasm-typed-arrays
[wasm] Typed Array support for better memory usage
2019-03-15 15:36:17 -05:00
Jo Shields 0f457095e5 Don't produce nunit-console scripts in bin/ (#13480)
NUnit bundle is gone, these scripts are empty and useless

```
10:27:45  DEBUG: Checking for unpackaged file(s): /usr/lib/rpm/check-files /builddir/build/BUILDROOT/mono-core-6.1.0.462-0.nightly.1.epel6.x86_64
10:27:45  DEBUG: BUILDSTDERR: error: Installed (but unpackaged) file(s) found:
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console2
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console4
10:27:45  DEBUG: RPM build errors:
10:27:45  DEBUG: BUILDSTDERR:     Installed (but unpackaged) file(s) found:
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console2
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console4
```
2019-03-15 19:16:15 +01:00
Johan Lorensson 36a2cabc7b Default to sgen on Windows x64. (#13473)
Since Boehm is not supported on Windows x64 we should set sgen as default
GC instead of forcing the use of --disable-bohem.
2019-03-15 12:12:10 -04:00
lateralusX 47ee8c8f46 Excluded some additional none Windows sources from win32_build/winaot profile. 2019-03-15 17:02:48 +01:00
Zoltan Varga db12fc8666 [wasm] Update to emscripten 1.38.29. 2019-03-15 10:33:37 -05:00
Justin Van Patten 202a217e15 Collection<T>: Validate parameters in the public methods (#23166)
I was looking over the new Range methods on `Collection<T>` and it occurred to me that for all existing methods, parameter validation is done in the *public* methods before calling the *protected virtual* methods. This changes the new Range methods to do the same.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-15 16:01:50 +01:00
lateralusX dab3cc35c0 Windows full AOT build scripts update.
* Only do clean/rebuild when an assembly changed.
* Add wrappers for different full AOT build configurations.
* Make scripts callable from different working directory.
2019-03-15 15:58:50 +01:00
Alexander Köplinger cfb3704940 [eglib] Remap g_utf16_len and g_utf16_len to monoeg_ prefix (#13476)
They fail a xamarin-macios public symbols check otherwise (monoeg_ is whitelisted).
2019-03-15 15:56:05 +01:00
Johan Lorensson f375ffd08c Merge pull request #13472 from lateralusX/lateralusX/enable-all-ci-tests-llvm-windows
Enable all CI test suites for Windows x64 full AOT + LLVM.
2019-03-15 10:27:13 -04:00
Zoltan Varga 9cdb5b4a12 [llvm] Fix receiving rgctx argument in DIM methods, they receive the mrgctx even if they are not generic. 2019-03-15 14:34:24 +01:00
Jo Shields 85ccf3ec02 Merge pull request #13437 from DavidKarlas/patch-1
Fix generating `.dSYM` for GTK assemblies
2019-03-15 09:15:15 -04:00
Bernhard Urban 4a2e7ce6f9 [mini] Remove public symbol helper_sig_llvmonly_imt_trampoline (#13462)
Fixes Xamarin.Tests.Misc.PublicSymbols test.
2019-03-15 12:34:43 +01:00
Marek Safar 2fa8290b7a Update for shared partition change 2019-03-15 11:20:43 +01:00
Egor Bogatov 6b2958e199 Move TypeLoadException to shared (dotnet/coreclr#23238)
* fix coding-style

* shorter form for TypeName property

* move coreclr-specific ctor to TypeLoadException

Signed-off-by: dotnet-bot <[email protected]>
2019-03-15 11:20:43 +01:00
Kenneth Pouncey b9bc111f01 Address review comments - Rename HostObjectInterface to IHostObject 2019-03-15 10:52:21 +01:00
Larry Ewingandkjpou1 e00dc00649 Update sdks/wasm/binding_support.js
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:34:16 +01:00
Larry Ewingandkjpou1 953acc3afd Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:32:57 +01:00
Larry Ewingandkjpou1 dd92015bbd Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:32:32 +01:00
Larry Ewingandkjpou1 caedcc8270 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:32:15 +01:00
Larry Ewingandkjpou1 e346211299 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:31:58 +01:00
Larry Ewingandkjpou1 e3a1b8714e Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:31:36 +01:00
Larry Ewingandkjpou1 b325eaacd1 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:31:10 +01:00
Larry Ewingandkjpou1 892b7ac039 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/ArrayBuffer.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:30:52 +01:00
Larry Ewingandkjpou1 4d17766a23 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:29:54 +01:00
Larry Ewingandkjpou1 e3ed42a492 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:29:37 +01:00
Larry Ewingandkjpou1 670b032653 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:29:22 +01:00
Larry Ewingandkjpou1 a4bb7611b8 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:29:11 +01:00
Larry Ewingandkjpou1 57aa52db5a Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:28:23 +01:00
Larry Ewingandkjpou1 6ff0679677 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:28:06 +01:00
Larry Ewingandkjpou1 3e4706cf24 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/ArrayBuffer.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:27:51 +01:00
Kenneth Pouncey 7708f047d6 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-03-15 09:35:47 +01:00
Marek Safar 0bd836b2f2 [System.Private.CoreLib] Remove unused variables from TypeNameParser 2019-03-15 09:28:07 +01:00
Marek Safar 25abfa4a3f [System.Private.CoreLib] Small StackTrace cleanup 2019-03-15 09:27:41 +01:00
lateralusX d06927eecf Move SafePasswordHandle to win32_build_corlib profile. 2019-03-15 09:20:03 +01:00
lateralusX 8a77ff6c05 Reverting changes to TimeZoneInfo test when reducing classes in corlib winaot. 2019-03-15 09:20:03 +01:00
lateralusX e36be73ffb Reduce number of classes in winaot mscorlib.
Winaot profile should be a Windows AOT friendly profile close to mobile
and consoles. At some point it was set to include the full net_4_x that
cause problems on none desktop platforms. This fix reduce the set to only
include classes similar to mobile and console profiles.
2019-03-15 09:20:03 +01:00
lateralusX 3fabfccb73 Enable all CI test suites for Windows x64 full AOT + LLVM. 2019-03-15 08:50:43 +01:00
Egor Bogatov e8a66f38da bump netcore sdk version 2019-03-14 23:39:05 +01:00
lateralusX 8a6a8b7f88 Fix missing llc options for Windows x64 full AOT + LLVM mini regression tests. 2019-03-14 16:39:36 -04:00
Vlad Brezae 73ff4a7434 [interp] Make sure we call init before registering counters (#13457)
[interp] Make sure we call init before registering counters
2019-03-14 15:55:56 -04:00
Jo Shields cd8dc77a8e [win] Don't try to install NUnit 2.4, it's dead now 2019-03-14 15:01:34 -04:00
Alexander Kyte b20b86ff11 Merge pull request #13247 from lateralusX/lateralusX/fix-llvm-dwarf-cfi-windows-x64
Fix LLVM Dwarf CFI on Windows x64. Bump to corresponding LLVM commit.
2019-03-14 13:30:48 -04:00
Kenneth Pouncey 9f2dd3f554 [wasm][doc] Add Packager doc (#13411)
* Add Packager doc

* Fix numbering

* Address review comments

Packager.exe to packager.exe

* Move packager readme doc from getting started as per review comment.

* - Addresses review comment -- Fix emdash in `packager.exe -help` command line.

* Fix command line argument -- instead of single -
2019-03-14 17:45:56 +01:00
Vlad Brezae 620a46d8f2 [profiler] Fix vtune build (#13390)
[profiler] Fix vtune build
2019-03-14 11:19:47 -04:00
Marek Safar c194209317 [netcore] Generate full project setup in gen-xunit-runner 2019-03-14 14:35:29 +01:00
Jb Evain 959fbda60a [sdb] Add property AssemblyMirror.HasDebugInfo (#13353)
* [sdb] Add property AssemblyMirror.HasDebugInfo

* Fix mono_debug_image_has_debug_info to work with ppdb

* Bump API snapshot submodule
2019-03-14 09:44:17 +01:00
Aleksey Kliger (λgeek) c0b48793db Custom modifier equivalence, duplication, appending and inflation (#13320)
This all stems from ECMA 335, 7.1.1:

> The CLI itself shall treat required and optional modifiers in the same
> manner. Two signatures that differ only by the addition of a custom
> modifier (required or optional) shall not be considered to match. Custom
> modifiers have no other effect on the operation of the VES.

This rule means that when comparing signatures, we have to treat two types that
differ only in their custom modifiers as distinct. In particular, we have to do
this when comparing signatures in order to fill in the vtable for a class.  And
moreover, we have to concatenate custom modifiers when doing generic
instantiation.  If a method in a generic type has signature `T modopt(IsConst)
Method()` and we instantiate T with `int32 modopt(IsLong)`, we are expected to
produce the signature `int32 modopt(IsConst) modopt(IsLong) Method()` (with the
custom modifiers on `int32` in that order).

So this PR implements the following operations:
1. custom modifier appending during `mono_metadata_type_dup_with_cmods`
2. custom modifier-respecting comparison in `do_mono_metadata_type_equal`

To do this, we actually have to introduce a second representation of custom
modifiers: in the normal representation, all the cmod type specs come from a
single image.  Whereas now, due to inflation of signatures, we can have a mix
of modifiers from different images.  So in the MonoAggregateModContainer
representation, we pair each typespec token with the image in which it is to be
resolved.

We keep the old representation (a single image to resolve the entire set of
typespec tokens) because it's natural when you're just reading from a single
image.  Also this representation is part of the embedding API.

---

### But that's not all ###


It is possible for generic parameters of a generic class to appear in the
_custom modifiers_ of a type in a method signature.  For example:
```
    T modopt(Nullable`1<T>) Method ()
```

In this case, when we inflate this signature, we need to inflate not only the
return type, but also the modifiers on a return type.

That means our old aggregate representation (where each modifier is a pair of a
MonoImage and a typespec token) is inadequate: we can inflate a signature and
get a custom modifier that doesn't appear as a typespec in any table of any
existing image.

This is the same situation as generic instances: as a program runs, it creates
generic instances that are not part of the source code.  So we solve it the
same way as with generic instances.

Our new `MonoAggregateModContainer` representation is a pointer into memory owned
by a MonoImageSet that contains an entire MonoType for each custom modifier.

The invariant is that the aggregate modifier container is allocated from a
mempool of a `MonoImageSet` that includes the images of all the modifiers.

In general, when inflating, we first create a provisional candidate
MonoAggregateModContainer on the stack and then look it up the image set that
should own it and then look for a "canonical" mod container in the
`MonoImageSet:aggergate_modifiers_cache`

---

Also had to bump the AOT image format, which now always reads back in using the aggregate representation.

---

This should address #10564, #10565, #12422, #10945 (again), #6936, and the parts of #11350 that **don't** deal with arrays.

---

TODO:

- [x] Add some representative test cases to this PR.
- [ ] Modify our acceptance tests to run the various disabled Roslyn tests.
2019-03-14 09:16:42 +01:00
Johan Lorensson 557d8406f6 Merge pull request #13444 from lateralusX/lateralusX/fix-simd-llvm-issue
Fix error in SIMD test on Windows x64 LLVM due to changed llc defaults.
2019-03-14 03:43:12 -04:00
Maxim Lipnin 55fbd14763 Remove nunit24 from mono build and tree (#13415)
* Remove nunit24 from mono build and tree

* More cleanup

* Fix build

* [csproj] Update project files
2019-03-13 23:47:39 +01:00
Levi Broderick f62dfab807 Add OperationStatus-based UTF8 transcoding APIs (dotnet/coreclr#23219)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-13 23:46:08 +01:00
Alexander Kyte 1a574284ac [crash] Fallback to MAP_ANONYMOUS for allocator
This is helpful by allowing the crash reporter to work even while
unable to write to the working directory.
2019-03-13 14:30:57 -04:00
Zoltan Varga 8fed6666b0 Address review comments. 2019-03-13 17:52:11 +01:00
Zoltan Varga dfb3ebd706 [netcore] Improvements to gen-xunit-runner.
* Add support for response files.
* Fix encoding of small primitive types.
* Print number of run/failed/skipped tests.
2019-03-13 17:52:11 +01:00
Zoltan Varga 23fea25e80 [netcore] Define COMPlus_DebugWriteToStdErr=1 in make run to enable debug logging. 2019-03-13 17:52:11 +01:00
Zoltan Varga c3d77000a7 [netcore] Test fixes.
* EqualityComparer.cs: Add LastIndexOf ().
* RuntimeAssembly.cs: Implement	       CreateAssemblyName ().
* AssemblyLoadContext.cs: Handle windows paths.		  Add DoAssemblyResolve () method.
* Array.cs: Add/fix error handling. Implement LastIndexOf ()/GetRawArrayData ().
* Attribute.cs:	    Implement.
* Buffer.cs: Add/fix error handling.
* DefaultBinder.cs: Implement.
* RuntimeType.cs: Implement HasSameMetadataDefinitionAs ().
* RuntimeEventInfo.cs: Ditto.
* RuntimeFieldInfo.cs: Ditto.
* RuntimeMethodInfo.cs: Ditto.
* RuntimePropertyInfo.cs: Ditto.
* MonoCustomAttrs.cs: Add eror handling. Implement inheritance support for parameters.
* gc.cs: Fix error handling.
* rttype.cs: Fix handling of null namespaces.
2019-03-13 17:52:11 +01:00
Zoltan Varga aa949e2114 [runtime] Add more error checking and special cases to the Array get/set icalls. 2019-03-13 17:52:11 +01:00
Zoltan Varga 46ae93a23c [runtime] Add a few more m_class accessors. 2019-03-13 17:52:11 +01:00
Zoltan Varga d5feee9c71 [runtime] Fix the ordering of the Buffer icalls. 2019-03-13 17:52:11 +01:00
Zoltan Varga 3dcee3319e [runtime] Avoid asserting if AppDomainUnloadedException is not found. 2019-03-13 17:52:11 +01:00
Zoltan Varga 7f9cb785f2 [runtime] Fix the creation of argument exceptions in netcore, the layout of ArgumentException is no longer visible to the runtime. 2019-03-13 17:52:11 +01:00
Zoltan Varga d7ba254448 [jit] Fix a IL verification error which the netcore tests run into. 2019-03-13 17:52:11 +01:00
Ankit Jain 4cb9a914f0 [msbuild] Update to track upstream vs16.0 branch (#13053) 2019-03-13 16:40:05 +01:00
Michal Strehovsky 90bdd5da71 Fix missed RelocatedType annotation
[tfs-changeset: 1735855]

Signed-off-by: dotnet-bot <[email protected]>
2019-03-13 15:58:58 +01:00
Aleksey Kliger d28aab8d56 [class-init] Take loader lock around mono_class_setup_interface_id_internal
Writing to MonoClass:interface_id must be done with the loader lock held.

Fixes assertion:
```
* Assertion at class-init.c:1830, condition `i == 0 || interfaces_full [i]->interface_id >= interfaces_full [i - 1]->interface_id' not met
```
2019-03-13 10:54:07 -04:00
lateralusX 9b440da1f2 Fix error in SIMD test on Windows x64 LLVM due to changed llc defaults. 2019-03-13 15:52:48 +01:00
Johan Lorensson eaa5805af7 Merge pull request #13393 from lateralusX/lateralusX/fix-build-warning-local-global
Fix build warning, local variable hides global.
2019-03-13 08:39:02 -04:00
Rolf Bjarne Kvinge a72e7ffc0d Revert "[mini] Inline Selector.GetHandle for tvOS and watchOS assemblies as well. (#13246)" (#13418)
Revert "[mini] Inline Selector.GetHandle for tvOS and watchOS assemblies as well. (#13246)"

This reverts commit c99fe4b462.

It doesn't work when LLVM is enabled for tvOS: https://github.com/xamarin/xamarin-macios/pull/5742#issuecomment-471007078, it causes multiple compilation errors like this:

    Process exited with code 1, command:
    /Applications/Xcode101.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang  -isysroot /Applications/Xcode101.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS12.1.sdk -Qunused-arguments -mtvos-version-min=12.1 -fembed-bitcode-marker -arch arm64 -c -o /private/var/folders/nh/n1y9qj2n40d7wpmx1mg9blg80000gn/T/mtouch.cache/arpl1vgs.js6/arm64/Xamarin.TVOS.dll-llvm.o -x assembler /private/var/folders/nh/n1y9qj2n40d7wpmx1mg9blg80000gn/T/mtouch.cache/arpl1vgs.js6/arm64/Xamarin.TVOS.dll-llvm.s
    /private/var/folders/nh/n1y9qj2n40d7wpmx1mg9blg80000gn/T/mtouch.cache/arpl1vgs.js6/arm64/Xamarin.TVOS.dll-llvm.s:4665:14: error: invalid variant 'OBJC_SELECTOR_REFERENCES_.2@PAGE'
            adrp    x8, l_@OBJC_SELECTOR_REFERENCES_.2@PAGE
                           ^
    /private/var/folders/nh/n1y9qj2n40d7wpmx1mg9blg80000gn/T/mtouch.cache/arpl1vgs.js6/arm64/Xamarin.TVOS.dll-llvm.s:4673:18: error: invalid variant 'OBJC_SELECTOR_REFERENCES_.2@PAGEOFF'
            ldr     x1, [x8, l_@OBJC_SELECTOR_REFERENCES_.2@PAGEOFF]




<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2019-03-13 08:05:48 -04:00
Alexis Christoforides f934b60854 [MacSDK] Bump Nuget to 4.8.2 2019-03-13 11:28:58 +01:00
Marek Safar fa7b007914 [System.Private.CoreLib] Remove duplicate checks 2019-03-13 10:35:25 +01:00
Sung Yoon Whang 6e85a0fb99 Add new counter APIs (dotnet/coreclr#23077)
* Refactor EventCounter and add PollingCounter

* Add PollingCounter

* Add IncrementingEventCounter and IncrementingPollingCounter

* Add MetaData API to Counters

* Some more refactoring

* removing commented out code

* some more cleanup

* build fix and addressing some PR comments

* Addressing PR feedback

* use StringBuilder to generate metadata string

Signed-off-by: dotnet-bot <[email protected]>
2019-03-13 10:03:41 +01:00
David Karlaš a716c9ad7b Fix generating .dSYM for GTK assemblies
Problem is that https://github.com/mono/bockbuild/blob/14535c270ea9f8d536efe6852700d8d1cb657c1f/packages/gtk%2B.py#L4 passes `gtk` for repository name to `GitHubPackage` which then uses this as package name. So when it's decided if `-g` should be added at https://github.com/mono/bockbuild/blob/5c2378112dc681cea0aa5c2447661fb13adbc46b/bockbuild/darwinprofile.py#L158-L159 it's false hence GTK assemblies don't get debug symbols.
2019-03-13 09:39:22 +01:00
Calvin Buckley 55d913c2d3 Bump corefx for System.Native posix_fadvise change (#13409) 2019-03-13 02:18:47 +01:00
Tanner Gooding cde76c1521 Fixing a couple of issues in the Utf8Parsing/Formatting code (#23134)
* Fixing NumberToSingle and NumberToDouble to handle DigitsCount == 0

* Fixing Utf8Formatter.Float to transcode non ASCII bytes

* Responding to PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-03-12 22:42:53 +01:00
Alexander Köplinger d884bd3e12 [corlib] Fix RuntimeFeatureTest.NoNewFeaturesAdded()
DefaultImplementationsOfInterfaces was enabled with https://github.com/mono/mono/pull/13417
2019-03-12 21:03:06 +01:00
Alexander Köplinger 92b435d6fe Move drawing types for XI/XM/wasm/orbis/unreal to System.Drawing.Common (#13414)
* Move drawing types for XI/XM/wasm/orbis/unreal to System.Drawing.Common

For XI/XM they were in Xamarin.iOS.dll/OpenTK-1.0.dll before.

For wasm/orbis/unreal we remove System.Drawing.dll from the profiles and
add the types to System.Drawing.Common.dll instead to align with the other
mobile profiles (only "net_4_x" and "build" still have System.Drawing.dll).

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-12 18:07:19 +01:00
Joshua Peterson 244c1aab8e Fix a possible crash while printing a warning (#13399)
The format string was incorrect in this case, which leads to a crash
in Unity. Simply remove the unused `%s` format specifier here.
2019-03-12 18:03:58 +01:00
monojenkins fb8554d76f [csproj] Update project files 2019-03-12 17:26:20 +01:00
monojenkins 0a85578bd0 Bump API snapshot submodule 2019-03-12 17:26:20 +01:00
Zoltan Varga 522a46dcac [corlib] Define FEATURE_DEFAULT_INTERFACES so RuntimeFeatures indicates DIMs are supported. 2019-03-12 17:26:20 +01:00
Kenneth Pouncey 205bb1666a [wasm][tests] Add WebSocket tests 2019-03-12 14:57:50 +01:00
Zoltan Varga 00c837d66a [netcore] Implement Type.GetType () overloads with assembly/type resolve delegates. (#13410)
Instead of extending the runtime gettype implementation, port the type parsing code
to C#.
2019-03-12 13:01:34 +01:00
Zoltan Varga ec7b9ec409 [jit] Implement Unsafe:ByteOffset<T> intrinsic. 2019-03-12 12:19:51 +01:00
Kenneth Pouncey 38ec3156f5 Address review by @Suchiman after conflict resolution. Thanks for the catch. 2019-03-12 11:02:28 +01:00
Kenneth Pouncey 9a73ea12b7 Confilct with Runtime.cs
Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays

# Conflicts:
#	sdks/wasm/framework/src/WebAssembly.Bindings/Runtime.cs
2019-03-12 10:11:04 +01:00
Larry Ewing 4ff1307e21 Remove all use of ContainsKey from js bindings (#13376) 2019-03-12 09:18:09 +01:00
Maxim Lipnin ad5fe197a3 Add reflected type to event methods (#13397)
Fixes https://github.com/mono/mono/issues/13350
Fixes https://github.com/mono/mono/issues/10277
2019-03-12 08:32:40 +01:00
Hugh Bellamy 030111234e Fix NRE in EqualStringArrays (dotnet/coreclr#23174)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-11 22:35:21 +01:00
Michal Strehovský 07c383b829 Replace Delegate.CreateDelegate (dotnet/corert#7147)
Replacing this with a pattern that is easier to statically analyze. We use the GetType/GetMethod/CreateDelegate pattern in several places already.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-11 22:20:53 +01:00
Alexander Köplinger b92a105992 [configure.ac] Fix configure checks for Mono.Native (#13395)
When the configure checks were ported from configure.cmake in corefx
a couple of mistakes happened:

- Using AC_TRY_COMPILE instead of AC_TRY_LINK:
  CMake's check_c_source_compiles() function compiles *and* links while
  AC_TRY_COMPILE only does the former. This hides potential linking issues
  which should fail the configure check.
- Using CFLAGS="-Werror -W....":
  This works in CMake but autoconf always appends the previously defined
  CFLAGS and since we set e.g. `-Wno-undefined` some configure checks
  would fail due to an unrelated warning being treated as an error.
  We need to only promot specific warnings to errors instead.

While looking at this I also found that we were setting CFLAGS after
we already AC_SUBST() it, we need to do this very close to the end of configure.ac.
Moved some code into that last block.

Finally, Android has special cases for sendfile and arc4random_buf where
they're defined in the header but aren't actually there for certain API profiles.
For now we disable arc4random_buf on Android and add a special check for sendfile.

* Fix sendfile with 6 parameters being misdetected

We need to make sure to actually prevent the implicit prototype since
in this case sendfile with different set of parameters actually exists
so the linker wouldn't fail.

Also fixed a few other cases of wrong configure checks due to missing headers.

* Move GSS checks into the Mono.Native checks section

This allows us to have a 1:1 mapping of the checks from configure.cmake
2019-03-11 20:36:40 +01:00
Thays Grazia 3537672955 [debugger] Fixing two crashes while debugging an Android app. (#13373)
* [debugger] Fixing two crashes while debugging an Android app.

-> Doing stepping into in VSM in some situation the frame saved in TLS is not synchronised with what is really been executed in the main thread. This makes the debugger-agent crashes because it tries to get variable info in some memory that is not available anymore.
	-> To fix it I forced the update of stack when CMD_THREAD_GET_FRAME_INFO is called.

-> Doing step over in Visual Studio for Windows, if you have the threads debugger window enabled, VSW calls frame_commands for each thread that is showed, and if the thread is not really_suspended it tries to get variable info from a memory that is not available anymore because the thread is not suspended yet.
	-> To fix it I don't send variable info of a frame if the thread is not really_suspended and doesn't have an async_state valid.

#Fixes 12843
2019-03-11 15:55:47 -03:00
Alexander Köplinger 0d7ce1f767 Fix build on Alpine Linux (#13394)
- sys/sysctl.h isn't available on Alpine and not needed by the code,
  guard it using HAVE_SYS_SYSCTL_H like elsewhere. Added by https://github.com/mono/mono/pull/11855

- pthread_mutexattr_setprotocol doesn't support PTHREAD_PRIO_INHERIT,
  check return value. Added by https://github.com/mono/mono/pull/13333
2019-03-11 16:59:44 +01:00
Kenneth Pouncey cbe835d0c1 Use new HostObject instead of NewJSObject. 2019-03-11 15:36:33 +01:00
Kenneth Pouncey 911b21dff4 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays
# Conflicts:
#	sdks/wasm/framework/src/WebAssembly.Net.Http/WasmHttpMessageHandler.cs
2019-03-11 15:24:26 +01:00
Egor Bogatov d0013e438c Add System.Drawing converters to netstandard facade (#13326)
This PR adds missing System.Drawing converters thus it completes NS2.1 support (as of today) for all profiles except macOS\IOS specific ones: monotouch, tv, watch, xammac, xammac_net_4_5.
2019-03-11 13:23:31 +01:00
Zoltan Varga db67d18d0d [netcore] Ongoing work. (#13391)
* [runtime] Add a few new m_class inline functions.

* [netcore] Implement Array.IndexOf ().

* [netcore] Implement RuntimeHelpers.PrepareMethod ().

* Add error checks to RuntimeHelpers.GetUninitializedObject ().
* Fix some type attributes.
* Fix some TypedReference special cases.
2019-03-11 08:16:21 -04:00
Zoltan Varga 38a2639fc1 [netcore] Fix build. (#13392)
* [netcore] Fix build.

* Update Buffer.cs
2019-03-11 12:57:44 +01:00
lateralusX ce3bbb011b Fix build warning, local variable hides global.
On Windows MSVC build this cause:

warning C4459: declaration of 'mono_cfg_dir' hides global declaration
2019-03-11 12:36:25 +01:00
Johan Lorensson ed3039b377 Merge pull request #13367 from lateralusX/lateralusX/fix-windows-build-warning
Fix build warning in mono-error.h.
2019-03-11 07:12:29 -04:00
Kenneth Pouncey b124b51066 Address review comments.
- Cleanup docs.
- Cleanup implicit conversions.
- Remove ToSpan()
2019-03-11 12:02:11 +01:00
Zoltan Varga ea761357f8 [jit] Reenable the EqualityComparer:Default devirt optimization. (#13321) 2019-03-11 06:09:59 -04:00
Calvin Buckley e9e52de223 Fix System.Decimal regression from .NET Core on big endian (#13348)
Upstream must have rewritten, because the runtime checks were
replaced with the (not good for Mono) ifdefs.

Not throughly tested, but unbreaks build locally; waiting for CI
to come back with more results.

If it works, could someone get this upstream?
2019-03-11 10:20:49 +01:00
Johan Lorensson a91e3f162a Merge pull request #13366 from lateralusX/lateralusX/add-missing-public-header-to-dist
Include mono-forward.h public header on Windows.
2019-03-11 04:29:42 -04:00
monojenkins 0e804950b5 [csproj] Update project files 2019-03-11 09:11:16 +01:00
monojenkins 0086403d54 Bump API snapshot submodule 2019-03-11 09:11:16 +01:00
Steve Pfister a49d5df03f These changes help prep for refsrc System.Web
* DynamicRoleClaimProvider to help with legacy role management in web forms
* Added AppDomainManagerAssembly, AppDomainManagerType, and PartialTrustVisibleAssemblies
  properties to AppDomainSetup. They don't do anything, but having  them there
  helps lessen the amount of change in refsrc System.Web.
2019-03-11 09:11:16 +01:00
Larry Ewing b5082160c3 Remove linq usage from WasmHttpMessageHandler 2019-03-11 09:10:59 +01:00
Levi Broderick 31b5a4554a Refactor Encoding to split fast-path and fallback logic (#23098)
This refactoring is limited to ASCIIEncoding at the moment, but it can easily be applied to UTF-8 / UTF-16 / UTF-32.

High-level changes:
- Fallback logic has been split from the fast-path, improving performance of GetBytes and similar routines.
- All of the plumbing of when to invoke the fallback logic and how to manage leftover data has been moved into the base class.
- Almost all of the logic except for the fast-path is now written in terms of verifiable code (Span and ReadOnlySpan).
- Minor bug fixes in EncoderNLS.Convert (see https://github.com/dotnet/coreclr/issues/23020).

Signed-off-by: dotnet-bot <[email protected]>
2019-03-11 09:05:29 +01:00
monojenkins db6ee0108b [bcl] Update BCL Linked Size 2019-03-11 09:01:51 +01:00
Bernhard Urban 2eeaf888c1 [AOT] add option to control arguments to llc and add fallback for x86 (#13323)
* [AOT] add option to control arguments to llc and add fallback for x86

Fixes https://github.com/mono/mono/issues/12182

* rename
2019-03-11 08:40:22 +01:00
Kenneth Pouncey 24a0e0d7f2 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-03-11 06:23:29 +01:00
monojenkins 3489679dc5 Bump API snapshot submodule 2019-03-10 13:11:12 +01:00
Steve Pfister 063f2a2b9a Added missing ToolLocationHelper methods that will be
used by refsrc System.Web.Compliation.AssemblyResolver.
2019-03-10 13:11:12 +01:00
Larry Ewing 5dbf642965 Add Blazor E2E test to wasm bcl-size-diff 2019-03-10 13:11:01 +01:00
Kurt Van Dijck 3e8108ea65 threads: set mutex PRIO_INHERIT in attribute (#13333)
threads: set mutex PRIO_INHERIT in attribute

When running multiple threads on a linux-rt kernel, with different priorities, the lack of priority-inheritance
makes the kernel make wrong scheduling choices.
This commit changes the system-wide mutex initializers.
This change protects our system against unexpected latencies in higher priority threads.

<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2019-03-09 23:35:34 -05:00
Marek Safar 4259cfad8f Remove local Buffer copy 2019-03-10 00:56:08 +01:00
Egor Bogatov 8a3a41b81a Move Buffer to shared (dotnet/coreclr#23157)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-10 00:56:08 +01:00
Dan Moseley 73caa49efb Remove 2 suffix step 1 (dotnet/corefx#35904)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-10 00:56:08 +01:00
Stephen Toub d5b0333f37 Add stack depth check to all Task continuations (dotnet/coreclr#23152)
Currently Task has a stack depth check that avoids stack overflows on very deep stack continuation chains, but it only applies to Task.ContinueWith, not to other kinds of continuations.  This changes that to have it apply to all.

As part of this, this also deletes the current StackGuard type used to achieve the check.  The type was meant to avoid expensive calls to check where we are on the stack, but now that we're using TryEnsureSufficientExecutionStack, it's actually faster to just call that rather than access the current StackGuard from a ThreadLocal.  This then also cleans up the call sites nicely, as they no longer need finally blocks to undo the increment performed on the StackGuard.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-09 17:48:20 +01:00
Zoltan Varga 92dfcb120b [netcore] Use codedom for code emission in the xunit generator. Add support for Theories and inline data. 2019-03-09 11:52:49 +01:00
Zoltan Varga 0f798ae6cf [netcore] Ongoing work. (#13357)
* [netcore] Implement MethodBody using internal Runtime* classes. Use the mono version for ModuleHandle.

* [netcore] Reflection fixes.

* Address review comments.

* [netcore] Implement RuntimeHelpers:GetUninitializedObject ().

* [netcore] Implement the Type::GetMethod () overload which has a genericParameterCount parameter.

* [netcore] Implement Thread.OptimalMaxSpinWaitsPerSpinIteration.

* Revert a change to fix a test failure.

* [netcore] Implement Marshal:GetExceptionForHRInternal ().

* [netcore] Implement GC:GetSegmentSize ().

* [runtime] Allow pointer type members in typed references.
2019-03-09 05:26:40 -05:00
Marek Safar dd0e9a8aa3 Fix the build 2019-03-09 09:27:46 +01:00
Marek Safar 289eb40af4 Move part of RuntimeHelpers to shared partition (dotnet/coreclr#23130)
* Move part of RuntimeHelpers to shared partition

* Remove FormatterServices.cs

Signed-off-by: dotnet-bot <[email protected]>
2019-03-09 09:27:46 +01:00
Steve Pfister 0306c38fed Add refsrc DataProtector to System.Security (#13365)
* Added DataProtector abstract class to be used when refsrc
System.Web gets ported over.

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-09 01:07:53 +01:00
Zoltan Varga 4401acd172 [jit] Avoid an assert with default interface methods and gsharing.
Fixes https://github.com/mono/mono/issues/13319.
2019-03-09 00:55:39 +01:00
Dotnet-GitSync-Bot 8efb2906d2 Mirror changes from mono/coreclr,corert (#13375)
* Added new Range Manipulation APIs for Collection<T> which propogate up to ObservableCollection<T>. AddRange, InsertRange, RemoveRange and Replace Range

Signed-off-by: dotnet-bot <[email protected]>

* Updated index out of range exception check to be a single comparison

Signed-off-by: dotnet-bot <[email protected]>

* Updated foreach to use T instead of var

Signed-off-by: dotnet-bot <[email protected]>

* Adding braces on for loop

Signed-off-by: dotnet-bot <[email protected]>

* Added ReplaceItemsRange API and updated ReplaceRange to invoke the protected method

Signed-off-by: dotnet-bot <[email protected]>

* Remove ternary operator from invocation as it is the same as inputing items.Count

Signed-off-by: dotnet-bot <[email protected]>

* Updated RemoveItemsRange to prevent int.MaxValue overflow errors

Signed-off-by: dotnet-bot <[email protected]>

* Updated RemoveItemsRange to properly remove each item and not just the index items

Signed-off-by: dotnet-bot <[email protected]>

* Added ArgumentOutOfRangeException exception in RemoveRange if the count is less than 0

Signed-off-by: dotnet-bot <[email protected]>

* Updated RemoveRange invocation of RemoveAt to use index instead of i, because the array changes with each iteration of the for loop and will cause side-effects which may include index out of range exceptions. This needs to be index because as the array shrinks the index is always at the correct position.

Signed-off-by: dotnet-bot <[email protected]>

* Updated RemoveAt->RemoveItem. This change removes redundent validation checks that happen using the RemoveAt API. RemoveItem gives us direct access to invoke the command

Signed-off-by: dotnet-bot <[email protected]>

* Updated InsertItemsRange to simplify the expression and added performance improvements. If the underlying `items` is using List<T> we should use it's InsertRange method since it is optimized, othersie we use InsertItem

Signed-off-by: dotnet-bot <[email protected]>

* Added new RemoveRange validation check to see if the resulting range (index + count) > items.Count and if it is true throw ArgumentException

Signed-off-by: dotnet-bot <[email protected]>

* Removed (Int64) cast statements from RemoveItemsRange when checking for overflow errors

Signed-off-by: dotnet-bot <[email protected]>

* InsertItemsRange API now checks if the underlying items.IsReadOnly first then collection == null

Signed-off-by: dotnet-bot <[email protected]>

* Simplified the RemoveItem logic since we have more robust validation

Signed-off-by: dotnet-bot <[email protected]>

* Optimized RemoveItemsRange to call the list.RemoveRange if the items is of type List<T>

Signed-off-by: dotnet-bot <[email protected]>
2019-03-09 00:51:26 +01:00
Filip Navara 19258e1680 Allow deserialization for ResourceManager created with non-default resource set type (#23051)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-09 00:44:14 +01:00
Johan Lorensson 2e30dbab63 Correctly defined thread API support for different Windows platforms. (#13344) 2019-03-08 14:34:49 -05:00
Zoltan Varga 6c81f5dbd2 [sdb] Avoid stack overflows caused by recursive calls between suspend_current () and invoke_method (). (#13362)
Fixes https://github.com/mono/mono/issues/13261.
2019-03-08 14:20:36 -05:00
Johan Lorensson 4c57215ca9 Fix GetTokenName to fail with exception on none Windows desktop platforms. (#13343) 2019-03-08 12:38:56 -05:00
Johan Lorensson 526939e146 Better probing logic on Windows when Unicode Win32 symbols are used. (#13345)
Several of the corefx interop sources uses the Unicode names of Win32 symbols.
Our current probing implementation on Windows will test the given name last
when nomangle is not provided (default). On Windows that will be a large number
of probes due to old stdcall name mangling rules. Fix makes sure we first test
the symbol against its charset and the given symbol, before trying the stdcall
name mangling rules. Will reduce the probing a lot on Windows for corefx Win32
interop classes.
2019-03-08 12:35:56 -05:00
Larry Ewing 27197d3f15 Add System.Runtime.Serialization targets 2019-03-08 10:36:31 -06:00
Larry Ewing f2b8ec3b3d Move the disabled tests under INCLUDE_DISABLED 2019-03-08 10:36:31 -06:00
Larry Ewing ad4e0414cd Add DataContractSerializer test 2019-03-08 10:36:31 -06:00
Larry Ewing a7f4dea649 Add linker test for Queryable 2019-03-08 10:36:31 -06:00
Alexander Köplinger 566e4565f4 [corlib] Remove Interop.MountPoints.cs from .sources (#13363)
* [corlib] Remove Interop.MountPoints.cs from .sources

We no longer need it since https://github.com/mono/mono/pull/13125 and having
it included makes xamarin-macios still complain about the missing symbol.

* [csproj] Update project files
2019-03-08 17:19:09 +01:00
lateralusX 7014dc1f8c Fix LLVM Dwarf CFI on Windows x64. Bump to corresponding LLVM commit. 2019-03-08 16:33:17 +01:00
lateralusX 5d5cb61243 Fix build warning in mono-error.h.
Warning (at least on Windows) due to unamed struct:

C4201, nonstandard extension used : nameless struct/union

Since the header can be consumed by embedders this warning should be
disabled.
2019-03-08 16:11:14 +01:00
lateralusX e9183496fb Include mono-forward.h public header on Windows. 2019-03-08 15:35:10 +01:00
Kenneth Pouncey e0651ded29 Add exclude features option when linking to the sdk. (#13340) 2019-03-08 15:22:36 +01:00
Johan Lorensson f89fdf28a3 Fix build warning in full AOT build. (#13342) 2019-03-08 06:37:46 -05:00
Marek Safar 63a58325b5 Remove unused type 2019-03-08 09:50:42 +01:00
Marek Safar 841a1d49b7 Use platform specific implementation of GetCurrentProcessId (#23084)
* Use platform specific implementation of GetCurrentProcessId

directly in shared location instead of relying on runtime export

* Move GetCurrentProcessId to Interop class

* Update ES_BUILD_STANDALONE build

Signed-off-by: dotnet-bot <[email protected]>
2019-03-08 09:50:42 +01:00
Marek Safar 14b0f985de Merge pull request #13356 from monojenkins/bclsizediff
[bcl] Update BCL Linked Size
2019-03-08 09:38:42 +01:00
Jb Evain 297b6ba328 [sdb] Avoid double lookup of replay packets 2019-03-08 09:34:54 +01:00
Dávid Kaya 8fc751180c Added UserFlags field, unblocks #34560 (dotnet/corefx#35851)
* Added UserFlags field

* Added UserFlags

Signed-off-by: dotnet-bot <[email protected]>
2019-03-08 07:39:21 +01:00
monojenkins b5daa32188 [bcl] Update BCL Linked Size 2019-03-08 03:38:14 +00:00
Alexander Köplinger 8cd69e14e3 Update System.Net.Http.csproj
Change missed in https://github.com/mono/mono/commit/97adf2e53e20c127bc38cb4f64a43f55c77e5c7e
2019-03-07 23:41:22 +01:00
Stephen Toub ad819c8921 Add missing CopyToAsync override in FileStream.Unix.cs (#23101)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 23:38:17 +01:00
Zoltan Varga 11349df4e6 [netcore] Add a tool to convert corefx test assemblies into simple test runners. (#13346)
* [netcore] Add a tool to convert corefx test assemblies into simple test runners.

* Fix computation of traits.
2019-03-07 22:50:42 +01:00
Hugh Bellamy f6179a0e68 Cleanup Globalization info code (dotnet/coreclr#22591)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 22:24:52 +01:00
Martin Baulig 97adf2e53e HttpClient for Web Assembly. 2019-03-07 21:49:27 +01:00
Alexander Köplinger 2e4d4a040c [sqlmetal] Distribute DbLinq.snk in tarball 2019-03-07 19:05:05 +01:00
monojenkins dbcd755c86 Bump API snapshot submodule 2019-03-07 18:47:03 +01:00
monojenkins ebb8b6fff2 [csproj] Update project files 2019-03-07 18:47:03 +01:00
Martin Baulig 2d6f02a83c HttpClient for Android. 2019-03-07 18:47:03 +01:00
Vlad Brezae deebdd1489 [interp] Add a few starting stats (#13347)
* [runtime] Use same single convention for stats tracking time

Also avoid useless mallocs/frees

* [interp] Add counters for transform phase
2019-03-07 11:53:11 -05:00
Kenneth Pouncey cad455b393 Fix HttpMessageHandler request content as binary. 2019-03-07 11:50:09 +01:00
Alexander Köplinger f77193d306 [mono/tests] Add fullaot-mixed to SUBDIRS
Fixes tarball build break.
2019-03-07 11:43:56 +01:00
Kenneth Pouncey 8d12c53c0a Fix ClientWebSocket passing of ArraySegment. 2019-03-07 11:35:16 +01:00
Kenneth Pouncey bb5eb13967 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays
# Conflicts:
#	sdks/wasm/framework/src/WebAssembly.Bindings/WebAssembly.Bindings.csproj
2019-03-07 10:10:59 +01:00
monojenkins 7fe2472b34 [csproj] Update project files 2019-03-07 10:03:14 +01:00
monojenkins 530596db02 Bump API snapshot submodule 2019-03-07 10:03:14 +01:00
Steve Pfister 6a9950c5d2 * System.Data.Linq now points to reference source
* Created SR and Strings helpers as refsrc resources are
  missing / incomplete

* Moved existing tests into the Test folder

* Moved old DBLinq code into tools/sqlmetal as there are no other
  alternatives.
2019-03-07 10:03:14 +01:00
Marek Safar c96df417d1 Remove code moved to shared 2019-03-07 00:42:25 +01:00
Tanner Gooding 57c75cbb94 Fixing the float/double parsing logic to handle exponents that are too large/small (#23043)
* Fixing the float/double parsing logic to handle exponents that are too large/small

* Fixing the debug assert to use >= and <=

* Fixing the max exponents to be +1 to match what scale uses.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Stephen Toub 6d8df4e7f3 Clean up some string.Format usage (dotnet/coreclr#23025)
* Clean up some string.Format usage

Mainly changes some string.Format usage to be SR.Format when working with resource strings.  Also cleans up a few asserts that were using string.Format.

* Address PR feedback and clean up src

* Address more feedback

* Update src/System.Private.CoreLib/shared/System/Type.Enum.cs

Thanks.

Co-Authored-By: stephentoub <[email protected]>
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Maryam Ariyan d56e47721a Add Type Forward (dotnet/coreclr#23036)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Marek Safar 72406ff802 Move more Assembly methods to shared partition (dotnet/coreclr#22817)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Andrew Au a7963f4e51 Fix issue 23009
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Honza Rameš d1b1ce9dfa Fix ValueStringBuilder.EnsureCapacity to call Grow correctly (#35810)
* Fix ValueStringBuilder.EnsureCapacity to call Grow correctly (#35746)

Call to EnsureCapacity may result in invalid buffer size being
allocated.

* Update ValueStringBuilder.Grow to prevent misuse (#35746)

Updated name of the argument to make it clearer on the call-site also
added summary co clearly state the behavior of Grow.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
dotnet-maestro[bot] 60de375154 Update dependencies from dotnet/core-setup (dotnet/corefx#35713)
* Update dependencies from https://github.com/dotnet/core-setup build 20190301.13

This change updates the following dependencies
- Microsoft.NETCore.App - 3.0.0-preview4-27501-13
- Microsoft.NETCore.DotNetHost - 3.0.0-preview4-27501-13
- Microsoft.NETCore.DotNetHostPolicy - 3.0.0-preview4-27501-13

* Remove workaround for System.Runtime.CompilerServices.Unsafe

* Update dependencies from https://github.com/dotnet/core-setup build 20190302.8

This change updates the following dependencies
- Microsoft.NETCore.App - 3.0.0-preview4-27502-8
- Microsoft.NETCore.DotNetHost - 3.0.0-preview4-27502-8
- Microsoft.NETCore.DotNetHostPolicy - 3.0.0-preview4-27502-8

* Update dependencies from https://github.com/dotnet/core-setup build 20190303.9

This change updates the following dependencies
- Microsoft.NETCore.App - 3.0.0-preview4-27503-9
- Microsoft.NETCore.DotNetHost - 3.0.0-preview4-27503-9
- Microsoft.NETCore.DotNetHostPolicy - 3.0.0-preview4-27503-9

* Update dependencies from https://github.com/dotnet/core-setup build 20190304.10

This change updates the following dependencies
- Microsoft.NETCore.App - 3.0.0-preview4-27504-10
- Microsoft.NETCore.DotNetHost - 3.0.0-preview4-27504-10
- Microsoft.NETCore.DotNetHostPolicy - 3.0.0-preview4-27504-10

* Don't include EventRegistrationToken on Unix

This type was accidentally duplicated between CoreLib and contracts.

Suppress that for now since we're detecting the duplication in the shared framework.

Make a fix in the shared items to restore the condition on this type.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Viktor Hofer af3965d9d2 Project msbuild syntax cleanup (dotnet/corefx#35686)
* Remove license header from non-shipping files

* Remove obsolete Project attributes

* Remove xml header and remove DefaultTargets

Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Michal Strehovský edf4941ec3 Fix ProjectN build breaks (dotnet/corert#7115)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Marek Safar 186ae08b0a Move fully managed TimerQueue implementation to shared partition (#7111)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Alexander Köplinger 97f2393f3e [mono/tests] Add common_mixed.mk to EXTRA_DIST 2019-03-06 23:58:48 +01:00
Alexander Köplinger 2f2881fc4b Add .gitignore for mono/tests/fullaot-mixed 2019-03-06 23:56:11 +01:00
Alexander Köplinger aabd3ab102 Bump bockbuild to get GTK fix
See https://github.com/mono/bockbuild/pull/90
2019-03-06 23:45:10 +01:00
Marek Safar fbffa8719a [System.Private.CoreLib] Fix the build 2019-03-06 23:05:20 +01:00
Martin Baulig 6034bc00c4 Introducing HttpClient.CreateDefaultHandler(). (#13305)
* The default `HttpClient` constructor now calls a static method `CreateDefaultHandler()`;
   we provide a platform-specific implementation of it.

* Replaced `HeaderUtils` with `PlatformHelper` and removed the `LEGACY_HTTPCLIENT` conditional.

* Added a new `socketshandler.sources` file to keep the sources in one place.

* Use a reflection check in the tests instead of the `LEGACY_HTTPCLIENT` conditional.

* This allows us to also get rid of the `SOCKETSHTTPHANDLER` define.
2019-03-06 20:56:42 +01:00
Zoltan Varga 835c8590ca [netcore] Implement DependentHandle using the existing ephemeron code. 2019-03-06 18:24:46 +01:00
Katelyn Gadd d02c43e23e Propagate type load errors out of IsAssignableFrom instead of erroneously returning false. Makes the underlying cause of #13113 discoverable. (#13324) 2019-03-06 11:41:55 -05:00
Ludovic Henry 6527e21bb4 [safepoint] Use LLVM pass to insert safepoint (#11789)
* [safepoint] Use LLVM pass to insert safepoint

This is to avoid safepoints to stop optimizations from happening.

* [safepoint] Use LLVM pass to insert safepoint

This is to avoid safepoints to stop optimizations from happening.

* fix error: emit_gc_safepoint_poll does not return anything

* Revert partial 4150f06f8621f2f2918e3bd747bf80a0f0f8c9c6

* Fix build

* [runtime] Add mono_threads_state_poll to preinited icalls

* [runtime] Adding back in safepoint icall skip code

* Revert mini.c to 100f422

* [runtime] Add missing deref to safepoint poll

* [runtime] Make safepoint functions have WeakODR linkage
2019-03-06 11:38:48 -05:00
Alexander Köplinger cacc9b7c4c [Facades] Add typeforwarders for DispatchProxy and TypeExtensions (#13325)
* [Facades] Add typeforwarders for DispatchProxy and TypeExtensions

DispatchProxy lives in System.Core for all profiles since https://github.com/mono/mono/pull/13198.

TypeExtensions live in corlib since https://github.com/mono/mono/pull/9746.

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-06 16:20:51 +01:00
Zoltan Varga 2b761f9ea5 [linker] Only preserve the m_value fields of the primitive types. 2019-03-06 11:34:34 +01:00
Egor Bogatov e42bf95d14 NS2.1 Sync new changes, mobile profiles (#13198)
* Add RuntimeHelpers.GetSubArray. Add missing types to NS's TypeForwarders.cs

* more NS2.1 changes

* ios changes

* Update Decimal (it's now readonly struct)

* fix mcs

* add ROMC.cs

* Fix tests, finish monodroid profile

* Make SRE-not-supported NS2.1 compatible

* Make monotouch_tv and watch NS2.1 compatible

* make some SRE types more NS21 compatible (non-abstract now)

* bump corefx

* More NS21 fixes

* bump coreclr acceptance tests

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-06 08:55:16 +01:00
Alexander Köplinger b31a445e85 [gitattributes] Do CRLF normalization on sln/proj files
They can be used with native line endings.

We now have a shared folder with the dotnet repos and they have CRLF normalization enabled.
This difference leads to conflicts while applying changes from the dotnet repos to mono.
2019-03-06 08:34:01 +01:00
justremotephone eb3f7312bd [System.ServiceModel] Fix a race condition in HttpRequestChannel. (#13304)
Concurrent request completions could cause following exception:

```
    FATAL UNHANDLED EXCEPTION: System.ArgumentOutOfRangeException:
        Index was out of range. Must be non-negative and less than
        the size of the collection.
        Parameter name: index
       at System.Collections.Generic.List`1[T].RemoveAt (System.Int32 index) [0x00009] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Collections.Generic.List`1[T].Remove (T item) [0x0000c] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.ServiceModel.Channels.HttpRequestChannel+HttpChannelRequestAsyncResult.Cleanup () [0x00011] in <28c4695205ef47378f5370502b066592>:0
       at System.ServiceModel.Channels.HttpRequestChannel+HttpChannelRequestAsyncResult.set_IsCompleted (System.Boolean value) [0x00034] in <28c4695205ef47378f5370502b066592>:0
       at System.ServiceModel.Channels.HttpRequestChannel+HttpChannelRequestAsyncResult.Complete (System.Exception ex) [0x0001a] in <28c4695205ef47378f5370502b066592>:0
       at System.ServiceModel.Channels.HttpRequestChannel+<>c__DisplayClass7_1.<BeginProcessRequest>b__0 (System.IAsyncResult r) [0x000bd] in <28c4695205ef47378f5370502b066592>:0

    This stack was captured after some changes in AwaitTaskContinuation.RunOrScheduleAction.
    Unfortunately the current implementation of AwaitTaskContinuation.RunOrScheduleAction re-throws the above
    exception with a wrong stack:

       at System.Threading.Tasks.AwaitTaskContinuation.RunOrScheduleAction (System.Action action, System.Boolean allowInlining, System.Threading.Tasks.Task& currentTask) [0x00023] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.FinishContinuations () [0x00052] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.FinishStageThree () [0x0003c] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.FinishStageTwo () [0x000a1] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.Finish (System.Boolean bUserDelegateExecuted) [0x00003] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.TrySetException (System.Object exceptionObject) [0x00023] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[TResult].SetException (System.Exception exception) [0x00029] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Net.HttpWebRequest+<RunWithTimeoutWorker>d__241`1[T].MoveNext () [0x000e0] in <3e9b3e26c4694baab3f689687ad40612>:0
       at System.Runtime.CompilerServices.AsyncMethodBuilderCore+MoveNextRunner.InvokeMoveNext (System.Object stateMachine) [0x00000] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.ExecutionContext.RunInternal (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, System.Boolean preserveSyncCtx) [0x00071] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.ExecutionContext.Run (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, System.Boolean preserveSyncCtx) [0x00000] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Runtime.CompilerServices.AsyncMethodBuilderCore+MoveNextRunner.Run () [0x00024] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.AwaitTaskContinuation.RunOrScheduleAction (System.Action action, System.Boolean allowInlining, System.Threading.Tasks.Task& currentTask) [0x00023] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.FinishContinuations () [0x00052] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.FinishStageThree () [0x0003c] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task`1[TResult].TrySetResult (TResult result) [0x0004f] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[TResult].SetResult (TResult result) [0x0003d] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Net.ServicePointScheduler+<WaitAsync>d__45.MoveNext () [0x000f7] in <3e9b3e26c4694baab3f689687ad40612>:0
       at System.Runtime.CompilerServices.AsyncMethodBuilderCore+MoveNextRunner.InvokeMoveNext (System.Object stateMachine) [0x00000] in <4a8a0
```

On an Android Xamarin installation this causes an app crash. Since no user code is active the exception cannot be caught.
2019-03-06 01:07:29 +01:00
Alexander Kyte 24c637dd26 Merge pull request #13262 from alexanderkyte/fixup_no_threads
[crash] Detect when 0 attached threads, fix hang/double-fault.
2019-03-05 17:38:16 -05:00
Maxim Lipnin 0e9495a034 Get fully qualified name of ModuleBuilder (#13308)
* Get fully qualified name of ModuleBuilder

* Use MethodBuilder.FileName to find main module
2019-03-05 16:20:47 -05:00
Kenneth Pouncey 9330096912 [wasm][ci]Update to latest JavaScript (engine) Version Updater (#13307)
- The purpose of this is to be able to respond to CI incidents faster for instance specific engine versions when JavaScript engines do not update/install correctly.
- This will install from a forked version of the jsvu repo: https://github.com/GoogleChromeLabs/jsvu
- Forked version rests here:  https://github.com/kjpou1/jsvu/tree/mono-wasm
   - The forked version removes the Node >= 10.0 dependency but brings in the newest 1.4.0 version modifications.
- This should be temporary until we get another solution i.e. a managed version of the engine updater.
2019-03-05 17:08:45 +01:00
Alexander Köplinger d99af881c3 [corlib] Disable ThreadPoolTest.GetAvailableThreads () on machines with many cores
It doesn't work well on the new 64 core ARM machines we have in CI.
2019-03-05 14:33:26 +01:00
Zoltan Varga af87454146 [jit] Avoid an assert when gsharedvt enums are boxed. (#13301)
Fixes https://github.com/mono/mono/issues/13297.
2019-03-05 01:21:02 -05:00
Alexander Köplinger c2a1eb5de6 [corlib] Improve ThreadPoolTest.GetAvailableThreads ()
Don't print console output in the loop and bump timeout.
2019-03-05 01:44:07 +01:00
Zoltan Varga 819660ef97 [netcore] Ongoing work.
* Implement all CustomAttributeExtensions methods.
* Add stubs for __ComObject which is needed by the runtime.
2019-03-04 19:33:46 +01:00
monojenkins 24d55fb184 [master] Fix mono conc hashtable lookup endless loop (#13292)
Fix mono conc hashtable lookup endless loop
2019-03-04 13:11:55 -05:00
monojenkins ef30f5589b [bcl] Update BCL Linked Size 2019-03-04 18:40:41 +01:00
Aaron Hill 290b537a73 Ensure that the module cctor is run before the entry point is executed (#13242)
* Ensure that the module cctor is run before the entry point is executed

We need to ensure that any module cctor for the 'main' image
is run *before* we invoke the entry point

This is required in order for tools like Costura
(https://github.com/Fody/Costura) to work properly. These tools inject
a module initializer which sets up event handlers (e.g. AssemblyResolve),
which allows the main method to run properly

For more information about module constructors,
see https://blogs.msdn.microsoft.com/junfeng/2005/11/19/module-initializer-a-k-a-module-constructor/

* Fix module-cctor-entrypoint.il
2019-03-04 12:31:17 -05:00
Alexander Köplinger e8fbaa5531 [linker] Fix monotouch tests which need Xamarin.iOS.dll (#13287)
The linker couldn't resolve Xamarin.iOS.dll which System.Net.Http references now.
2019-03-04 17:46:56 +01:00
Egor Bogatov af6d863e52 [corlib] Fix Directory.GetLogicalDrives () (#13125)
Fixes #13030
2019-03-04 16:43:46 +01:00
sancheolz 89f264ad86 [SWF] Method OnClosed should pass FormClosedEventArgs type, instead of EventArgs.Empty (#13283)
Fixes #13282
2019-03-04 15:31:59 +01:00
Bernhard Urban 1da9c0f9e7 [interp] mixed mode fixes for delegates (#13215)
* [interp] avoid multiple transformations

* [interp] remove delegate hack for method_ptr=imethod case

it isn't needed anymore

* [interp] ensure initialized fields of a class retrieved from wrapper data

* [fullaot mixed] add test for specific mixed mode scenario

* [interp] remove assertion, it does not take into account multiple threads transforming the same method

* [interp] avoid non-lazy compilation of delegate if interpreter is involved

* [fullaot-mixed] disable on i386

* [interp] propagate errors on delegate init

* fix c++ build

* [tests] improve return codes

* error only for dynamic methods

* [fullaot-mixed] disable test on coop
2019-03-04 15:06:35 +01:00
sancheolz bac5347996 [System.Runtime.Remoting] Implement CustomErrorsMode for RemotingConfiguration (#13251)
Implemented property RemotingConfiguration.CustomErrorsMode.

Fixes #13250
2019-03-04 15:01:40 +01:00
Marek Safar a08eff03f7 [System.Private.CoreLib] Implement more APIs 2019-03-04 12:58:03 +01:00
Zoltan Varga 85c8e85476 [netcore] Ongoing work. (#13278)
* Implement CustomAttributeExtensions methods.
* Add a AssemblyFileVersion attribute.
* Don't try AppDomain.TypeResolve.
2019-03-04 11:59:37 +01:00
Zoltan Varga f82ae71c90 [netcore] Fix threading. 2019-03-03 13:42:10 +01:00
Zoltan Varga 6b6b1ce35e [jit] Fix the RuntimeHelpers.ObjectHasComponentSize () intrinsics. (#13271) 2019-03-03 06:58:11 -05:00
Jan Kotas 9bdb423e5d Fix CoreCLR build break
Signed-off-by: dotnet-bot <[email protected]>
2019-03-03 12:12:26 +01:00
Jan Kotas 6578e93670 Update CoreRT for changes in shared partition
Signed-off-by: dotnet-bot <[email protected]>
2019-03-03 12:10:25 +01:00
Marek Safar 519139773f Fix the build 2019-03-03 12:01:00 +01:00
Marek Safar 243d669a2e Move Activator to shared partition (dotnet/coreclr#22894)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-03 12:01:00 +01:00
Grant d8e9e8fa6d Use BitOperations in more callsites (CoreCLR) (dotnet/coreclr#22630)
* Missed perf improvement in EventProvider

* Add missing methods to StubEnvironment

Signed-off-by: dotnet-bot <[email protected]>
2019-03-02 23:07:39 +01:00
Jan Kotas 84d6476152 Fix CoreFX build break
Signed-off-by: dotnet-bot <[email protected]>
2019-03-02 21:10:37 +01:00
Jan Kotas a31af4add7 Fix netfx build break
Signed-off-by: dotnet-bot <[email protected]>
2019-03-02 21:10:37 +01:00
Alexander Köplinger 64556b9bb9 [ci] Shorten timeout in SDKs tests
The tests normally complete in a few mins.
2019-03-02 12:46:27 +01:00
Calvin Buckley 2ecf08d265 More PPC/AIX regression fixes (#13264)
* Fix System.Math regressions brought on by PowerPC JIT optimizations

	* While frin[.] does do rounding, the semantics are slightly
	  different enough from the BCL that it subtly breaks, as
	  seen by some tests. Ceil/Floor/Trunc are fine, however.
	  Perhaps the sysmath.c version can be translated to asma.

	* Fix typo where signed long comparison for isel was using
	  an unsigned comparison.
	  Add a test for this in the JIT regression check.

* Link against (not fd.o) libbsd for System.Native on AIX

The way we link the library by default will allow some unresolved
symbols. These will get resolved to the runtime when loaded by it.
However, flock isn't in AIX libc, and the native library needs it.
This doesn't seem to be a problem on AIX, but on i libbsd doesn't
seem to be in the dependency chain, so it errors out when you use
it. The workaround is to link libbsd (not the freedesktop.org one)
into the library. According to dump, it seems it has its own copy
of ioctl and fnctl, but they seem benign according to objdump and
don't seem to affect System and corlib tests I've ran to check it.
2019-03-02 12:43:12 +01:00
Marek Safar 30d70e98e6 Fix the build 2019-03-02 11:05:00 +01:00
Morgan Brown 580f5ef53a Implement Serialization Guard
Add Serialization Guard API and consume it in CoreLib targets

Signed-off-by: dotnet-bot <[email protected]>
2019-03-02 11:05:00 +01:00
Maxim Lipnin ed0d055424 Throw InvalidOperationException if inner handler is not assigned 2019-03-02 02:31:54 +01:00
Alexander Kyte db5d8729b4 [crash] Detect when 0 attached threads, fix hang/double-fault. 2019-03-01 16:11:11 -05:00
Zoltan Varga 4970e055b3 [netcore] Implements threads. (#13245)
* [netcore] Implements threads.

There is only one thread object, since there are no domains.

* Make the start callback internal.
2019-03-01 15:15:31 -05:00
Ludovic Henry 234daf1cf3 [android] Fix Mono.Debugger.Soft tests with Android SDKs (#13218)
* [android] Fix Mono.Debugger.Soft tests with Android SDKs

* [android] Fix connecting with LLDB

* [android] Add scaffolding to run profiler tests

* [android] Fix some corlib tests

* [android] Fix Mono.DebuggerTests.ExceptionFilter2

* [csproj] Update project files
2019-03-01 21:03:26 +01:00
Rolf Bjarne Kvinge c99fe4b462 [mini] Inline Selector.GetHandle for tvOS and watchOS assemblies as well. (#13246) 2019-03-01 11:10:04 -05:00
monojenkins 83d5cf0c5c [android] Fix inaccurate detection of sendfile() (#13243)
[android] Fix inaccurate detection of sendfile()
2019-03-01 10:28:34 -05:00
Alexander Kyte 23c83a48cd [runtime] Optimize array_set_value_impl slow path (#13186)
* [runtime] Add unmanaged fast-path for mono_class_is_assignable_from

Our managed code has a fast path for this that checks if the two types
are the same. The unmanaged calls here always falls back on the slow path.

This leads to a latency that is pretty observable during
array_set_value_impl calls.

* [runtime] Make faster already-pinned nullable init path

* [runtime] Expose non-handle-allocating object_handle_isinst_mbyref

* [runtime] Use MONO_ENTER_NO_SAFEPOINTS for array_set_value_impl
2019-03-01 10:21:02 -05:00
Vlad Brezae e4b281825a [interp] Add fast paths for common cast checks (#13225)
* [interp] Remove some duplicated code

* [interp] Optimize type checking for interfaces

Mainly to avoiding handles for common scenarios. Makes type checking for common interfaces 10x faster.

* [interp] Optimize type checking for common classes

Mainly to avoiding handles for common scenarios. Makes type checking for common classes 10x faster.
2019-03-01 10:19:12 -05:00
Alexander Köplinger 98e0f2697d [sdks] Use throttle() instead of lock()
The former works in freestyle builds.
2019-03-01 14:45:16 +01:00
Alexander Köplinger f5b9af2505 Revert "[sdks] Make sure to run only one build per type per node"
This reverts commit b740313aa5.

We actually want to only run one build per product on a node,
e.g. so that android-debug and android-release can't run on
the same node and stomp on each other's toolchain.
2019-03-01 13:57:06 +01:00
Alexander Köplinger 793c3aa3aa [ci] Add node name to log of Jenkins pipeline builds
Makes it easier to figure out where a build ran.
2019-03-01 13:31:01 +01:00
Alexander Köplinger 5bf74a9954 [System.Net.Http] Move NSUrlSessionHandler from xamarin-macios to mono (#13229)
* [System.Net.Http] Move NSUrlSessionHandler from xamarin-macios to mono

This allows us to remove the need for a special custom System.Net.Http.dll
build in the xamarin-macios repository.

Part of #11397

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-01 12:20:27 +01:00
Katelyn Gadd 6c58376102 If a ClientIdentity has no ClientProxy then return null from the accessor instead of throwing. Experimental partial fix for issue #13113 2019-03-01 11:59:50 +01:00
Levi Broderick fcbc8c3792 Add Rune.DecodeUtf16 / DecodeUtf8 and friends (dotnet/coreclr#22725)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-01 09:57:09 +01:00
Aaron Robinson 3508069707 Move COM related attributes to the shared source location of Object class. (#22942)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-01 09:57:09 +01:00
Tanner Gooding 5b02347ae8 Removing the ExtractVector128 and InsertVector128 APIs that take an address. (#22886)
* Removing the InsertVector128 and ExtractVector128 overloads that take an address from S.P.Corelib

* Removing the ExtractStore and InsertLoad tests.

* Fixing the PacketTracer test to use the appropriate Extract/InsertVector128 overloads

* Removing the JIT support for the Extract/InsertVector128 overloads that take an address.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-01 09:54:21 +01:00
monojenkins 041e874182 [bcl] Update BCL Linked Size 2019-03-01 09:32:07 +01:00
Alexis Christoforides adc62b328e [monodroid] Use CoreFX to implement System.Drawing types that used to be in Mono.Android.dll (#13135)
* [monodroid] Use CoreFX to fill in reference stubs for System.Drawing types that are currently 'forked' from Mono into Mono.Android.dll

The list of localy implemented System.Drawing types: https://github.com/xamarin/xamarin-android/blob/e0da1f152de84c4cc39983f2fda775ec98c08250/src/Mono.Android/Mono.Android.csproj#L311-L325

* [netstandard] Update for Mono.Android change

* Bump reference assemblies to include Mono.Android update

* Use System.Drawing.Common to find moved types in monodroid case for netstandard facade

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-01 01:50:44 +01:00
Alexander Köplinger 4ea57007fa [Mono.Debugger.Soft] Disable Attach() test that fails or hangs (#13239)
It was recently reenabled in #9091 but it fails/hangs frequently.
2019-03-01 01:43:19 +01:00
Aaron Robinson b5d6e5344f Set the MarshalByRefObject to be ComVisible and (dotnet/coreclr#22930)
a IDispatch class interface. this is being done
  to ensure WinForms consumers can interact with
  COM based controls.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-01 00:28:08 +01:00
Stephen Toub b0935ae258 Fix DumpAsync to understand ContinuationWrapper (dotnet/coreclr#22913)
Continuations created while the debugger is attached or certain EventSource events are enabled end up getting wrapped in an extra ContinuationWrapper object that carries some additional information.  DumpAsync currently isn't unwrapping these but should.  This just teaches it to look for a known field name so that it can "see through" these wrappers while following async "stacks".

Signed-off-by: dotnet-bot <[email protected]>
2019-02-28 23:30:53 +01:00
Marek Safar a88ad66551 Build fixes 2019-02-28 23:05:24 +01:00
Jan Kotas 51a4aae4ff Fix CoreRT build break
Signed-off-by: dotnet-bot <[email protected]>
2019-02-28 23:05:24 +01:00
Stephen Toub ee67c17eb3 Address PR feedback (clean up style in Thread.CoreCLR.cs)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-28 23:05:24 +01:00
Stephen Toub 54d2a05d66 Fix Thread-related breaking changes
- Thread.ExecutionContext needs to return ExecutionContext.Capture() to public callers.
- Fix restoring of culture to be inside of the ExecutionContext callback where applicable

Signed-off-by: dotnet-bot <[email protected]>
2019-02-28 23:05:24 +01:00
Marek Safar 4c4421f30d Fix the build 2019-02-28 22:41:40 +01:00
Filip Navara d14b15f502 Move Thread to shared CoreLib (dotnet/coreclr#22744)
* Move Thread to shared CoreLib

* Remove all local variables from Thread in shared code

* Remove duplicate checks

* Port back CoreRT changes needed for shared code

* Fix missing culture initialization in ThreadStart()

* Adjust for shared WaitHandle

Signed-off-by: dotnet-bot <[email protected]>
2019-02-28 22:41:40 +01:00
Johan Lorensson 80e5e7ff62 Cancel sync IO on Windows when aborting thread. (#13173)
* Cancel sync IO on Windows when aborting thread.

Using CancelIO/CancelIOEx or CancelSynchronousIo on a thread that is moving
into a suspended state can cause these calls to hang (they shouldn’t but
have been observed to be the case). Fix does the cancel of sync IO after
the aborted thread has been resumed, but before releasing suspend locks
making sure thread won't be suspend again until after cancel IO call has
completed.

* Add tests aborting blocking socket and file IO on Windows.
2019-02-28 16:02:21 -05:00
Alexander Köplinger e3caf01677 [sdks] Use abspath instead of PWD on iOS app build (#13230)
PWD is the wrong directory when e.g. you're doing "make -C sdks/ios" from the repo root.

Fixes https://github.com/mono/mono/issues/13224
2019-02-28 21:47:21 +01:00
Mikhail Filippov f512a68edc [Mono.Debugger.Soft] Add new debugger tests and fix the Attach() test (#9091)
* Fixed the Attach() test which required a free port to attach.

* Added test for incorrect events behavior when VM is started with suspend

* Bump API snapshot submodule
2019-02-28 19:29:30 +01:00
Calvin Buckley a4eee02195 PPC JIT optimizations (System.Math instruction inlining) (#11964)
* [ppc] Optimize floating point performance in the JIT sqrt/sqrtf/abs

* [ppc] Integer Min/Max inlining wiht POWER5 isel instruction

Compresses a function call down to two instruction, for both signed
and unsigned, long and int. Needs to check for POWE5 though, and I
don't know the effects of this on ppc32. FP version using fsel is
also desirable, but not in the scope of this commit.

* [ppc] Check for POWER5 compatible CPU before using isel

* [ppc] Don't use long min/max inlining for ppc32

Other 64-bit operations are marked for ppc64 only.

* [ppc] also ifdef that out for ppc32 too

* [ppc] Rounding function optimizations
2019-02-28 09:31:12 -05:00
Johan Lorensson 3487962a82 Merge pull request #13210 from lateralusX/lateralusX/adjust-test-console-output
Update output from console-output test.
2019-02-28 06:40:33 -05:00
Johan Lorensson dd9ee189c6 Merge pull request #13212 from lateralusX/lateralusX/add-waitforkeypress-test-project
Add atexit-waitforkeypress handler in Visual Studio mono.sln test projects run args.
2019-02-28 05:06:38 -05:00
monojenkins ace38db535 [bcl] Update BCL Linked Size 2019-02-28 08:24:51 +01:00
Martin Baulig 3f43547cd6 [corlib]: Use Guid.NewGuid() implementation from CoreFx. (#13189)
* [corlib]: Use `Guid.NewGuid()` implementation from CoreFx.

The corefx implementation of `Guid.NewGuid()` uses the internal
`Interop.GetRandomBytes(byte*, int)`, which uses `RNGCryptoServiceProvider`
directly without using `CryptoConfig`.

* [csproj] Update project files

* Rename Guid.MonoTouch.cs -> CommonCrypto/Guid.cs.
2019-02-28 00:37:25 -05:00
Ludovic Henry 53b7b79f53 Initial support for Fuchsia (#13200)
* Initial support for Fuchsia

Compile like this:

if you have Zircon installed, with the prebuilts on "../zircon", use this to compile:

CC="`pwd`/../zircon/prebuilt/downloads/clang/bin/clang-9 -nostdlib -O2 -g -fdebug-prefix-map=/cvs/fuchsia/zircon=. -finline -fno-common -ffunction-sections -fdata-sections -no-canonical-prefixes -march=x86-64 -mcx16 --target=x86_64-fuchsia -fPIC -D_ALL_SOURCE=1 -DENABLE_DRIVER_TRACING=1 -fasynchronous-unwind-tables -fno-omit-frame-pointer  -std=c11 -I`pwd`/../zircon/build-x64-clang/sysroot/include/ -I`pwd`/../zircon/system/public" LDFLAGS="-L`pwd`/../zircon/build-x64-clang/sysroot/lib/ -L`pwd`/../zircon/build-x64-clang/sysroot/debug" ./configure --host=x86_64-google-fuchsia

* Use HOST_FUCHSIA rather than TARGET_FUCHSIA
2019-02-27 21:33:15 -05:00
Bernhard Urban 69cb9ad922 [interp] fix conflict of #13154 and #13177 (#13208)
See https://github.com/mono/mono/pull/13177#discussion_r259872514
2019-02-27 21:32:37 -05:00
Bernhard Urban 2030ebdc5e [interp] compute size of generic valuetype correctly (#13216)
[interp] compute size of generic valuetype correctly

Otherwise we smash the stack.


Contributes to https://github.com/xamarin/xamarin-macios/issues/5622
2019-02-27 18:25:40 -05:00
Calvin Buckley a3be248d3f [corlib] Simplify RuntimeInformation by getting OS name from the runtime (#13164)
We can get the the OS name similar to the architecture from the value that is used by the runtime for DllMaps.

Cached the values into static fields so we only need to do the runtime icall once.

Added all the existing OS names recognized by DllMap to RuntimeInformation.
This also allows us to mark some corlib/System tests that hang the runtime on AIX as non-working.
2019-02-27 23:21:34 +01:00
Miguel de Icaza fe92cea485 Use HOST_FUCHSIA rather than TARGET_FUCHSIA 2019-02-27 16:54:50 -05:00
Bernhard Urban a3dd8b3246 [lldb] fix helper for interpreter stacktraces (#13211)
Broke due to b6775765ed
2019-02-27 21:55:14 +01:00
Marek Safar 6f8ec5fdce Fixes build 2019-02-27 21:24:21 +01:00
Grant 448fd6ac62 Make BitOperations public (CoreCLR) (dotnet/coreclr#22864)
* Make BitOps public

* Update name to BitOperations

* Change namespace to System.Numerics

* Fix file name

* Alphabetical

Signed-off-by: dotnet-bot <[email protected]>
2019-02-27 21:24:21 +01:00
Maxim Lipnin 1ab0ffc964 [corlib] Update DriveInfo tests to use the newer RuntimeInformation APIs (#13205) 2019-02-27 19:23:19 +01:00
lateralusX 695743e3ab Add atexit-waitforkeypress handler in Visual Studio mono.sln test projects run args. 2019-02-27 17:45:57 +01:00
lateralusX ac906dd937 Update output from console-output test.
Current output from console-output test is just Error and Out (indicating)
the different console output streams. When seen in log files the error output
string can be misleading. Fix makes it clearer that the output is originating
from a test and not an “error”.
2019-02-27 17:19:30 +01:00
Zoltan Varga 8ca41f08a0 [jit] Fix the class of the stack entry for ldelema, it should be the class not its element class. (#13134)
Fixes https://github.com/mono/mono/issues/10101.
2019-02-27 16:31:54 +01:00
Martin Baulig 55a34261c9 [Mono.Security]: minor CryptoConvert changes to make it more linker-friendly. (#13204)
* Add new internal `CryptoConvert.TryImportCapiPrivateKeyBlob()` method that's using `RSAManaged` directly to make it more linker-friendly.

* Also add new internal `CryptoConvert.TryImportCapiPublicKeyBlob()`.

* Use it in `AssemblyName.IsPublicKeyValid`.
2019-02-27 12:56:06 +01:00
Zoltan Varga ce2259d009 [runtime] Default Interface method fixes. (#13154)
* [runtime] Inflate overridden methods properly during vtable construction when using default interface methods.

* [jit] Handle default interface methods in constrained calls, they need to box if the constrained type is a valuetype which doesn't override the default method.

* [runtime] Update Default Interface Methods tests from coreclr.

* [jit] Fix interp support.
2019-02-26 22:00:46 -05:00
Ankit Jain f7d053a0d6 nuget-hash-extractor: Improvements to reduce unnecessary diffs on update (#13197)
* [nuget-hash-extractor] Make the order for denied lists deterministic and

.. stable. We were not sorting the list of assemblies with the same
version, causing irrelevant changes in updates.

* Update denied assembly list to fix order

.. to be deterministic. Generated with the updated
nuget-hash-extractor.cs .

* [nuget-hash-extractor] Make the order of assemblies deterministic

The .nupkgs were being processed in arbitrary order, causing unncessary
diffs when updating them which required manual work to check and fix
them.
2019-02-27 00:41:11 +01:00
Martin Baulig 6a3b12b622 Revert "[Mono.Security]: minor CryptoConvert changes to make it more linker-friendly." (#13202)
This reverts commit ef7e64a5be.
2019-02-27 00:17:37 +01:00
Stephen Toub 48f65d5108 Special-case 1 module per assembly in Assembly.GetTypes/DefinedTypes (#22825)
It's very common for an assembly to have only one module, in which case we can avoid unnecessary allocations and copies in Assembly.GetTypes() and Assembly.DefinedTypes.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-27 00:03:26 +01:00
Dotnet-GitSync-Bot 2b4bff1956 Mirror changes from mono/coreclr (#13192)
This PR contains mirrored changes from mono/coreclr


**Please REBASE this PR when merging**

 cc @grant-d
2019-02-26 23:59:38 +01:00
Ludovic Henry a685cf26a4 [ci] Add new mode of execution for nunit tests on Android (#13098)
* [ci] Add new mode of execution for nunit tests on Android

This makes it possible to run the `nunit-lite-console.exe` on the host, while the tests still run on the device. This makes it transparent wherever the tests are running, giving us a seamless integration with the existing infrastructure based around nunit.

* [android] Fix System.Net.Http test suite

* [android] Fix System.ServiceModel.Web test suite

* [android] Fix Mono.Security test suite

* fixup! [ci] Add new mode of execution for nunit tests on Android

* [ci] Disable failing tests

* [csproj] Update project files
2019-02-26 22:08:01 +01:00
Miguel de Icaza a55e8496be Initial support for Fuchsia
Compile like this:

if you have Zircon installed, with the prebuilts on "../zircon", use this to compile:

CC="`pwd`/../zircon/prebuilt/downloads/clang/bin/clang-9 -nostdlib -O2 -g -fdebug-prefix-map=/cvs/fuchsia/zircon=. -finline -fno-common -ffunction-sections -fdata-sections -no-canonical-prefixes -march=x86-64 -mcx16 --target=x86_64-fuchsia -fPIC -D_ALL_SOURCE=1 -DENABLE_DRIVER_TRACING=1 -fasynchronous-unwind-tables -fno-omit-frame-pointer  -std=c11 -I`pwd`/../zircon/build-x64-clang/sysroot/include/ -I`pwd`/../zircon/system/public" LDFLAGS="-L`pwd`/../zircon/build-x64-clang/sysroot/lib/ -L`pwd`/../zircon/build-x64-clang/sysroot/debug" ./configure --host=x86_64-google-fuchsia
2019-02-26 15:55:41 -05:00
Zoltan Varga 5f5ef1efe5 [wasm] Disable chakra tests until its fixed. (#13199) 2019-02-26 21:41:46 +01:00
Vlad Brezae 88c560ad72 [interp] Avoid clearing the stack with each call (#13177)
* [interp] Move special case initialisation of frame->ip

* [interp] Properly init locals

When we have locals that need to be initialized.

* [interp] Load the entire enum value

When calling calling method on constrained type for enums with long storage.

* [interp] Avoid clearing the stack with each call

Reducing overhead for each call, this can give an overall performance improvement of 5%.
2019-02-26 12:01:29 -05:00
Alexander Kyte a0c6a15465 [runtime] Use FastCopy on multidimensional arrays (#13181) 2019-02-26 10:09:46 -05:00
Maxim Lipnin fc240aaa1c Consider unknown GB18030 characters as invalid to enforce use of replacement character instead of throwing SystemException. (#13188)
* Consider unknown GB18030 characters as invalid to enforce use of replacement character instead of throwing SystemException.

* Return negative result for unknown character instead of throwing SystemException in GB18030Source.FromUCS
2019-02-26 12:51:51 +01:00
Zoltan Varga 5225828263 [corlib] Add a RuntimeTypeHandle::GetCorElementType () icall, use it to remove a few other small icalls. 2019-02-26 12:51:14 +01:00
Alexander Köplinger 97f0a0f94c [ci] Use dl.internalx.com when building on private Jenkins
(cherry picked from commit 9d4aa950aa)
2019-02-26 11:25:45 +01:00
Martin Baulig ef7e64a5be [Mono.Security]: minor CryptoConvert changes to make it more linker-friendly.
* Add new internal `CryptoConvert.TryImportCapiPrivateKeyBlob()`
  method that's using `RSAManaged` directly to make it more
  linker-friendly.

* Use it in `AssemblyName.IsPublicKeyValid`.
2019-02-26 10:18:54 +01:00
Kenneth Pouncey 07287648b2 [wasm] Add browser test suite. (#13145)
* [wasm] Add browser test suite.

- Runs a series of tests against the HttpClientHandler and blob tests.

* Setup custom browser launcher to pass `--no-sandbox` to work on CI

* Remove auto client config that caused async errors on tests.
2019-02-26 10:07:21 +01:00
Marek Safar 7c975c18d8 AssemblyLoadContext from shared 2019-02-25 23:39:31 +01:00
Marek Safar 5ae98353a6 Move AssemblyLoadContext to shared partition (dotnet/coreclr#22685)
* Move AssemblyLoadContext to shared partition

* Move static initializer to DefaultAssemblyLoadContext

and remove stream copying from lock scope

Signed-off-by: dotnet-bot <[email protected]>
2019-02-25 23:39:31 +01:00
Martin Baulig 7f3a127b6d Remove unused (and broken) mono_btls_ssl_ctx_get_servername(). (#13184) 2019-02-25 20:15:17 +01:00
Bernhard Urban fc171a192a [aot] abort lookup early when a method isn't available in AOT image (#13138)
[aot] abort lookup early when a method isn't available in AOT image

Mixed mode depends on that.  Usually, compile_method of mini takes care
to request only existing methods from the AOT image, but in some cases,
e.g. from a trampoline, AOT runtime is quiered directly.

Contributes to https://github.com/xamarin/xamarin-macios/issues/5618
2019-02-25 10:56:15 -05:00
Jay Krell 2f3f58c7f1 [mkbundle] Fix mapping length (#13061)
* https://github.com/mono/mono/issues/11643 mkbundle problem - Illegal byte sequence

The size of the mapping is the maximum file offset to map.
See https://docs.microsoft.com/en-us/windows/desktop/Memory/creating-a-file-mapping-object.

When I tried it, I got a different error.

If in the debugger you simulate this fix, it gets further.

Here is a small program to exercise and see the behavior:

```
// include <windows.h>
// include <stdio.h>
// include <stdlib.h>
//
// int main()
// {
//  // Create a 128K file.
//
//  HANDLE file = CreateFile("1", GENERIC_READ | GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
//  printf("createfile %p %d\n", file, GetLastError());
//
//  HANDLE map = CreateFileMapping(file, 0, PAGE_READWRITE, 0, 1 << 17, 0);
//  printf("createmap %p %d\n", map, GetLastError());
//
//  CloseHandle(map);
//  CloseHandle(file);
//  system("dir");
//
//  // Attempt to map the second 64K of the 128K file, with a 64K mapping.
//
//  file = CreateFile("1", GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
//  printf("createfile %p %d\n", file, GetLastError());
//
//  map = CreateFileMapping(file, 0, PAGE_READWRITE, 0, 1 << 16, 0);
//  printf("createmap %p %d\n", map, GetLastError());
//
//   // This fails.
//
//  PVOID view = MapViewOfFile(map, FILE_MAP_WRITE, 0, 1 << 16, 1 << 16);
//  printf("view %p %d\n", view, GetLastError());
//
//  CloseHandle(map);
//
//  // Use a 128K mapping instead. It works.
//
//  map = CreateFileMapping(file, 0, PAGE_READWRITE, 0, 1 << 17, 0);
//  printf("createmap %p %d\n", map, GetLastError());
//
//  view = MapViewOfFile(map, FILE_MAP_WRITE, 0, 1 << 16, 1 << 16);
//  printf("view %p %d\n", view, GetLastError());
// }
```

Here is debugging mono and simulating the fix in the debugger (I did not build or test
the fix):

```

\bin\amd64\cdb C:\Users\jaykrell\Downloads\output\output.exe

0:000> bm kernel*!*createfilemap*
0:000> g

Breakpoint 2 hit
KERNELBASE!CreateFileMappingW:
00007ffd`0a449de0 4883ec48        sub     rsp,48h
0:000> dv
                  hFile = 0x00000000`00000200
lpFileMappingAttributes = 0x00000000`00000000
              flProtect = 2
      dwMaximumSizeHigh = 0
       dwMaximumSizeLow = 0x477000
                 lpName = 0x00000000`00000000 ""

0:000> bm kern*!*mapviewoffile*
0:000> g
Breakpoint 38 hit
KERNEL32!MapViewOfFileStub:
00007ffd`0b09bfa0 48ff2591c10500  jmp     qword ptr [KERNEL32!_imp_MapViewOfFile (00007ffd`0b0f8138)] ds:00007ffd`0b0f8138={KERNELBASE!MapViewOfFile (00007ffd`0a465ad0)}
0:000> dv
  hFileMappingObject = 0x00000000`00000204
     dwDesiredAccess = 4
    dwFileOffsetHigh = 0
     dwFileOffsetLow = 0x30000
dwNumberOfBytesToMap = 0x477000
0:000> gu
0:000> r rax
rax=0000000000000000
0:000> !gle
LastErrorValue: (Win32) 0x5 (5) - Access is denied.
LastStatusValue: (NTSTATUS) 0xc000001f - {Invalid Mapping}  An attempt was made to create a view for a section which is bigger than the section.

0:000> .restart
0:000> bm kernel*!*createfilemap*
0:000> g
0:000> dv
                  hFile = 0x00000000`00000220
lpFileMappingAttributes = 0x00000000`00000000
              flProtect = 2
      dwMaximumSizeHigh = 0
       dwMaximumSizeLow = 0x477000
                 lpName = 0x00000000`00000000 ""
0:000> ?? dwMaximumSizeLow += 0x30000
unsigned long 0x4a7000
0:000> bc *
0:000> g
Corlib not in sync with this runtime: The runtime did not find the mscorlib.dll it expected. Expected interface version CA4932AE-2294-4ECD-B863-BF98FDD84F33 but found 0CC970F6-6F25-4218-9427-3E4C3DC8DE33. Check that your runtime and class libraries are matching.
Loaded from: mscorlib.dll
Download a newer corlib or a newer runtime at http://www.mono-project.com/download.

```

* Restore useful part of comment.

* Restore dead code.

* Add to comment the other possibility that is being countered.

* Additional explanation.
2019-02-25 09:48:04 -05:00
Johan Lorensson e6d259b82c Fix multiple issues with response file option on Windows. (#13132)
* Fix multiple issues with --response file option on Windows.

* If file is UTF8 encoded and include BOM mark, implementation failed to
detect and remove BOM mark causing errors. Fix check for BOM mark and if
found, remove it before passed to parsing. NOTE, current implementation
only supports UTF8 (and ASCII) content in response file and won't detect
or handle any other codepages.

* Since the content in --response file should mimic what should have been
passed on command line, we should apply same parsing rules on Windows as done
by the shell when running the arguments on the command line. Current
implementation uses its own parsing that is not the same as used by the Windows
shell, meaning that arguments can't be identical in response file compared to
what's passed on command line. This commit fix parsing of the command
line in the response file so its first parsed by the shell before added
to internal argc, argv parameters (similar as done when passed to main function).

* Add support to handle new lines in response file on Windows.
2019-02-25 09:42:44 -05:00
Radek Doulik 4a96c5e715 [aot] Resolve profile against compiled assembly (#13148)
[aot] Resolve profile against compiled assembly

When trying to use AOT profile in XA for assembly AOT compilation, the
methods from the profile were not compiled.

Context: https://github.com/xamarin/xamarin-android/issues/2504

The problem was, the profile data were not resolved, as there was no
assembly loaded in the domain.

With this fix, the compiled assembly is used to resolve the profile as
well.
2019-02-25 08:35:48 -05:00
Marek Safar ecef8d334a [System.Private.CoreLib] Implement more APIs 2019-02-25 13:51:30 +01:00
monojenkins 8a417e9cb6 Bump API snapshot submodule 2019-02-25 13:30:32 +01:00
Martin Baulig aee90aca7c Make System.dll internals visible to Mono.Android. 2019-02-25 13:30:32 +01:00
Zoltan Varga c94af71bf0 [corlib] Hardcode IsRunningOnWindows as false on WASM too. (#13161) 2019-02-25 03:18:28 -05:00
Kenneth Pouncey fdbebe278e Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-02-25 04:54:45 +01:00
Zoltan Varga 6644136745 [wasm] Update to emscripten 1.38.28. (#13160)
* [wasm] Update to emscripten 1.38.28.

The emscripten patch is no longer needed.

* [wasm] Disable optimizations in SHA1Transform (), the normal version seems to cause stack overflows in binaryen's asm2wasm tool.
2019-02-24 22:50:31 -05:00
Zoltan Varga f52f874aae [wasm] Small fixes. (#13166)
* [wasm] Disable an unused icall which has an invalid signature under wasm.

* [aot] Make the dedup pass less verbose.
2019-02-24 22:42:55 -05:00
Eric StJohn b936c53101 Make System.Runtime.CompilerServices.Unsafe inbox (dotnet/corefx#35526)
* Make System.Runtime.CompilerServices.Unsafe inbox

Fix a couple places where we wanted to use it from other inbox assemblies but couldn't.

Unsafe remains as a package and newer versions of Unsafe will replace the inbox Version,
permitting us to add API over time.

* Update Rune tests to use TryEncodeToUtf8Bytes directly

* Add temporary suppression to package tests

Signed-off-by: dotnet-bot <[email protected]>
2019-02-23 08:52:41 +01:00
Ankit Jain 6df26e8287 [nuget] Add new versions of System.Net.Http
.. to the list of denied assemblies. Added `4.3.4`.

Prompted by issue #12603 .
2019-02-23 08:51:03 +01:00
Ankit Jain ae240f1f8e [nuget] Add new versions of System.Text.Encoding.CodePages ..
.. to the list of denied assemblies. Added:

- `4.5.0`
- `4.5.1`

Fixes issue #12603 .
2019-02-23 08:51:03 +01:00
Jan Kotas 6df88479c8 Change Environment.Version to return product version (dotnet/coreclr#22664)
* Change Environment.Version to return product version

- Contributes to https://github.com/dotnet/corefx/issues/31099
- Use AssemblyInformationalVersion attribute as fallback

* Add sanity test for Environment.Version

* Disable CodeDom tests

* Fix test assembly name

Signed-off-by: dotnet-bot <[email protected]>
2019-02-23 08:49:36 +01:00
Stephen Toub b0d3ead369 Ignore EINVAL/EBADF errors from FTruncate in FileStream.Init (#22788)
They indicate we're working with a special file, where failure to truncate is not a fatal condition.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-22 22:24:37 +01:00
Vincent Dondain 0525583d1e [System] Bump SocketTest.TestSelect1 socket timeout to 1ms (#13152)
- Previous test with 100 micro second timeout would fail on iOS device when running **all the socket tests** about 3 times out of 5.
- With a 1 millisecond timeout, it didn't fail the 10 times I tried locally, hopefully this is enough to fix the flakiness.
- Fixes #8360: [System.Net.Sockets] flakey failures of SocketTest.TestSelect1 on Darwin systems
  (https://github.com/mono/mono/issues/8360)
- Also partial fix for maccore issue https://github.com/xamarin/maccore/issues/1069
2019-02-22 21:28:06 +01:00
Kenneth Pouncey 80f8aa27b1 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays
# Conflicts:
#	sdks/wasm/Makefile
2019-02-22 14:24:14 +01:00
Ankit Jain a4fada3900 [fsharp] Fix a type inference error introduced by recent changes (#13109)
```
@/external/bockbuild/builds/fsharp-fsharp-6624925/src/scripts/fssrgen.fsx(334,28): error FS0041: A unique overload for method 'GetFileNameWithoutExtension' could not be determined based on type information prior to this program point.
A type annotation may be needed. Candidates: System.IO.Path.GetFileNameWithoutExtension(path: System.ReadOnlySpan<char>) : System.ReadOnlySpan<char>, System.IO.Path.GetFileNameWithoutExtension(path: string) : string
[@/external/bockbuild/builds/fsharp-fsharp-6624925/src/fsharp/FSharp.Build-proto/FSharp.Build-proto.fsproj]
```
2019-02-22 08:00:41 -05:00
Bernhard Urban 3be2390665 [aot] add wrappers to "slim" mscorlib (i.e. --aot=interp) (#13137)
* [aot] add gc wrappers in interp scenario

* [aot] add icall wrappers in interp scenario
2019-02-22 07:59:53 -05:00
Zoltan Varga 55c998d282 [aot] Only emit the static interp trampolines/wrappers into the mscorlib AOT image. (#13117) 2019-02-22 07:58:57 -05:00
Ludovic Henry 49b6628370 [aot] use unbox arbitrary trampolines for "slim" mscorlib (#13139)
We need the recently introduced "unbox arbitrary" trampolines in one more
scenario: non-mscorlib AOT code calls a method from mscorlib with
interpreter. Before we just relied on the amodule not being available,
but mscorlib amodule is always present due to wrappers, trampolines,
etc.
2019-02-22 07:57:16 -05:00
Vlad Brezae b6775765ed [interp] Cleanup code a little (#13092)
* [interp] Cleanup code a little

* [interp] Rename rtm to imethod
2019-02-22 07:55:37 -05:00
Thays Grazia 1e1e0b6b01 [wasm] [debugger] Add test suite. (#13093)
* [wasm] [debugger] Add test suite.

* [wasm] [debugger] Add test suite.

* [wasm] [debugger] Add test suite.

* Changing what Larry suggested and removing some -debug that is not used.

* Adding the DebuggingTestSuite.

* indentation

* Update run-jenkins.sh
2019-02-22 07:52:59 -05:00
Zoltan Varga 50ce9ed8e5 [netcore] Implement AppContext. 2019-02-22 10:19:37 +01:00
monojenkins 66e88b1e6b [bcl] Update BCL Linked Size 2019-02-22 10:03:28 +01:00
Bernhard Urban af46af33a1 [jit/cprop] insert dummy insn if first insn of basic block got replaced (#13127)
[jit/cprop] insert dummy insn if first insn of basic block got replaced

Fixes https://github.com/mono/mono/issues/13056 & https://github.com/mono/mono/issues/13057
2019-02-21 21:05:34 -05:00
Bernhard Urban 8891a4b778 [aot] use unbox arbitrary trampolines for "slim" mscorlib
We need the recently introduced "unbox arbitrary" trampolines in one more
scenario: non-mscorlib AOT code calls a method from mscorlib with
interpreter. Before we just relied on the amodule not being available,
but mscorlib amodule is always present due to wrappers, trampolines,
etc.
2019-02-21 23:28:41 +01:00
Zoltan Varga 2124448a37 [runtime] Move mono_get_context_capture_method () from security-manager.c to object.c. (#13071) 2019-02-21 16:26:05 -05:00
Maxim Lipnin 506406df06 Try to extract valid drive name from DriveInfo ctor string argument (#13105)
It's possible to pass any string as an argument to DriveInfo ctor (e.g.  `new DriveInfo(Path.GetTempPath())`). Mono throws ArgumentException if there is no exactly the same drive name in the list of available drives.

I tried to handle this case by extracting any valid drive name from the array of available drives sorted by path in descending order.

Fixes https://github.com/mono/mono/issues/12157
2019-02-21 21:57:55 +01:00
Marek Safar 020ce70e30 [System.Private.CoreLib] Implement more APIs 2019-02-21 21:34:18 +01:00
Martin Baulig 7277e3bb5e SslStream improvements and tests
* Add server-side Server-Name-Indication (SNI) support (both AppleTls and BTLS).

* Support the new `SslServerAuthenticationOptions.ServerCertificateSelectionCallback`.

* Server certificate selection is now compatible with CoreFx behavior; first
  checking the new `ServerCertSelectionDelegate` then `LocalCertSelectionCallback`
  and finally using an explicitly provided certificate.

* Misc exception checks and fixes to make behavior consistent with CoreFx;
  any exception thrown by reading / writing the underlying stream will now be
  propagated verbatim (and not wrapped in an `AuthenticationException`);
  exceptions thrown by the handshake / TLS stack itself will still be wrapped.

* Added `System.Net.Security` xUnit tests from CoreFx.

* Misc test cleanups; moved certificate test files from `System.Net.Http` into
  `System` and embed them in the test assembly as resources, adjusting
  `test-helpers/Configuration.Certificates.cs` accordingly.
2019-02-21 20:43:25 +01:00
Zoltan Varga aa04713723 [llvmonly] Do null checks on interp transitions for virtual->non virtual calls. (#13118)
Fixes https://github.com/mono/mono/issues/12998.
2019-02-21 12:24:14 -05:00
Alexander Köplinger b740313aa5 [sdks] Make sure to run only one build per type per node
They could conflict while provisioning android toolchains etc. otherwise.
2019-02-21 17:33:41 +01:00
Ankit Jain bda914c9b5 [bockbuild] Bump to master HEAD to get new fixes (#13108) 2019-02-21 17:19:27 +01:00
Zoltan Varga 576b1a0827 [llvm] Mark the branch in OP_GC_SAFE_POINT as taken. (#13114) 2019-02-21 10:08:04 -05:00
Kenneth Pouncey 7038d1915a Small cleanup 2019-02-21 14:05:08 +01:00
Kenneth Pouncey 49b92c95d0 Modify public interface CopyTo and CopyFrom to use lightweight Span<U>.
- Modifications in response to review comments.
2019-02-21 14:03:24 +01:00
Johan Lorensson 6f786bc465 Disable Mono.CSharp on Windows x64 full AOT test. (#13124)
Not part (and should not be) part of the winaot profile and therefore not testable (even though they pass when manually AOT:ing the assembly).
2019-02-21 13:29:34 +01:00
Vlad Brezae ff84ee290e [runtime] Remove dead code (#13089)
[runtime] Remove dead code

Interface method calls on constrained types are resolved in get_method_constrained now (apparently since https://github.com/mono/mono/commit/3259e04ace67552fc8d63a8f1ddbb830e526f05f)
2019-02-21 06:55:48 -05:00
Tanner Gooding af1034a99c Enable the HWIntrinsic extension methods and remove the instance implementations (#22705)
* Removing various S.R.I.Vector instance method APIs, since they should now be exposed as extension methods

* Updating the JIT to recognize the S.R.I.Vector extension methods.

* Updating various S.R.I.Vector test templates

* Regenerating the S.R.I tests that are created from a template.

* Fixing the numArgs for Base_Vector256_GetLower

* Fixing the handling for `Base_VectorXXX_As` to normalize the struct type.

* Adding the Base_Vector128_As intrinsics back for arm64

Signed-off-by: dotnet-bot <[email protected]>
2019-02-21 12:26:09 +01:00
Nikolay Sivov ffd601eed4 Fix some compiler warnings (#13044)
Fix some compiler warnings

Compiled with gcc 8.2.0/x86_64-linux-gnu.
2019-02-21 06:05:47 -05:00
Vlad Brezae 809e40435f [tests] Fix function signature (#13090)
[tests] Fix function signature

To match pinvoke signature from pinvoke-2 test.
2019-02-21 04:15:53 -05:00
Johan Lorensson 3622703cbe Enable all CI test suites for Windows x64 full AOT. (#13102) 2019-02-21 10:04:20 +01:00
Ben Adams bcdc345b44 Reduce struct copy by 1 in ValueTask.GetAwaiter (dotnet/coreclr#22738)
* Reduce struct copy by 1 in ValueTask.GetAwaiter

* Bit more explicit

Signed-off-by: dotnet-bot <[email protected]>
2019-02-21 10:02:14 +01:00
Filip Navara 5d36e4b2a7 Move Thread to shared CoreLib (dotnet/corefx#35462)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-21 10:00:54 +01:00
Zoltan Varga b4943dec39 [jit] Fix the loaded llvm build. (#13110) 2019-02-21 03:45:36 -05:00
Zoltan Varga d48b84d67f [llvm] Fix a 'incoming phi sreg1' llvm failure which happens with valuetypes+phi nodes. (#13077)
[llvm] Fix a 'incoming phi sreg1' llvm failure which happens with valuetypes+phi nodes.

Fixes https://github.com/mono/mono/issues/12988.
2019-02-21 03:35:54 -05:00
Aleksey Kliger (λgeek) 72512cfbcb [loader] Fix off by 1 (netstandard is a framework facade) (#13111)
[loader] Fix off by 1 (netstandard is a framework facade)

Before 5e0d39a8a1, there used to be a handwritten binary search that traveersed `framework_assemblies` to determine if a given assembly was a framework assembly or not.  The binary search used `last = G_N_ELEMENTS (framework_assemblies) - 1` as the initial condition, but it used an inclusive `first <= last` as the loop count.

After we switched to a hashtable, we used the same final value initialize `assembly_remapping_table`.

We didn't notice because `mscorlib` used to be the last assembly in the table and `mscorlib` already has a ton of special handling in the loader.  But `netstandard` is not special.  So we added it to the table, but it still doesn't get special handling.

This should fix instances where code references netstandard 2.0.0.0, but we give it netstandard 2.1.0.0

https://github.com/mono/mono/blob/f8094319132d2d40f37e8cac6058e783b5648260/mono/metadata/assembly.c#L345
2019-02-21 01:45:50 -05:00
Stephen Toub f809431913 Use ThrowHelper in ManualResetValueTaskSourceCore (dotnet/coreclr#22714)
Just move the helper being used to ThrowHelper.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 22:47:35 +01:00
Stephen Toub a5e27b6316 Fix bug introduced during cleanup in JapaneseLunisolarCalendar (#22717)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 20:24:29 +01:00
Ben Adams bce27a80de Allow Task.WaitAny completion to run synchronously (dotnet/coreclr#21245)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 20:24:29 +01:00
Johan Lorensson 795dc5ebd2 Remaining fixes needed to pass rest of CI test suites for windows x64 full AOT. (#13084)
* Fix for runtime mcs-compileall test on Windows x64 full AOT.

Test picked up full AOT:ed libraries as well as managed libraries failing
the test. Full AOT:ed shared libraries on Windows has .dll.dll prefix and
full AOT:ed executables on Windows has .exe.dll prefix.

Fix makes sure to filter out any files ending with dll.dll or exe.dll.

* Fix build errors in System.Web.Services test under winaot profile.

* Fix errors in System.Core test under winaot profile.

* Fix build error in linker tests on Windows under winaot profile.

Build fails since profile build mscorlib is used as well as default
triggering build error. Fix is to build linker tests using -nostdlib flag.
2019-02-20 14:17:10 -05:00
Johan Lorensson 3bcebfb0a0 Don't install jay as part of make install. (#13086)
Should not be part of the package and cause issues on Windows 32-bit
cygwin build since it's not using makefile generated by autotools. When
make install is run it will build jay one more time, but picking up
cygwin default gcc compiler instead of the one used in configure step, mingw.
That cause link errors since the object files are not rebuild, only relinked
with different linker, causing errors.
2019-02-20 14:01:03 -05:00
Alexander Köplinger 78ef5a9722 [ci] Prefer gmake over make for SDKs build (#13091)
Apple's make doesn't support the --output-sync option and Homebrew's make is installed as gmake.

Also fixed a few places in the repo where we directly invoked make instead of $(MAKE).
2019-02-20 19:46:54 +01:00
Marek Safar 951803d082 [System.Private.CoreLib] Implement more APIs 2019-02-20 17:55:17 +01:00
Stephen Toub 5ec1def012 Fix race condition in ManualResetValueTaskSourceCore (dotnet/coreclr#22711)
* Fix race condition in ManualResetValueTaskSourceCore

ManualResetValueTaskSourceCore.GetStatus is used from ValueTaskAwaiter.IsCompleted.  If GetStatus returns Success too early, then IsCompleted will also return true too early, which will result in GetResult being called too early.  This doesn't happen today when an MRVTSC is used sequentially.  But if an instance is pooled by the object its stored on getting put back into a pool as part of a call to the wrapper's GetResult, then we can end up in the following situation:
- Thread 1 starts an await on an instance containing an MRVTSC.  It calls IsCompleted.
- Thread 2 starts to complete that instance, getting as far as calling SignalCompletion and setting _completed to true but not yet setting _continuation.
- Thread 1 sees _completed == true and returns true from IsCompleted.  It calls GetResult, and the wrapper extracts the result from the instance, resets it, and puts it back into the pool.
- Thread 3 takes the object out of the pool and starts using it.
- Thread 2 continues SignalCompletion on that instance, and sets _continuation to the sentinel.
- Now Thread 3's instance's _continuation is the sentinel when it should be null.  If it calls SignalCompletion, it'll erroneously find that _continuation is not null and will queue _continuation/_continuationState for execution, resulting in the sentinel getting executed.  If it calls OnCompleted, it'll find that the _continuation is not null, and will queue the supplied continuation/state to execute immediately even though the operation may not yet actually be done.

The fix is simply to check not just _completed but also _continuation.  The operation is considered pending if either _completed is false, meaning SignalCompletion has not yet been called, or if _continuation is still null, meaning it's neither been set to the supplied delegate nor to the sentinel.  We can't just rely on _completed for the above outlined reasons, and we can't just rely on _continuation because it can be non-null if OnCompleted was called to hook up a callback (if we only cared about the await pattern, then we could just check _continuation and wouldn't need _completed, but we also need to support non-await access).

* Address PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 13:02:45 +01:00
Alexander Köplinger 3ac43f72bb Update sdks-archive.groovy android packages 2019-02-20 11:46:36 +01:00
Egor Bogatov 3c41d74f1e NS2.1: System.Security.Cryptography changes (#13022)
* NS21: X509Store, rsa.cs

* More NS2.1 changes

* remove X509Stubs.cs

* Add corert/CancellationTokenRegistration.cs

* Implement Socket.ReceiveAsync

* Add X509Certificates stubs

* bump corefx and corert

* bump corefx

* remove corefx/tmp

* Bump API snapshot submodule

* [csproj] Update project files
2019-02-20 11:43:26 +01:00
monojenkins fceb9471e2 [bcl] Update BCL Linked Size 2019-02-20 09:16:55 +01:00
Jan Kotas ad4c22c4f4 Use out arguments in UmAlQuraCalendar (dotnet/coreclr#22704)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 09:13:30 +01:00
Kenneth Pouncey 16f1845a19 Fix spacing 2019-02-20 07:30:24 +01:00
Kenneth Pouncey 2e4713cb39 Fix spelling 2019-02-20 07:29:49 +01:00
Kenneth Pouncey d60440869c Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-02-20 06:40:15 +01:00
Ludovic Henry 7f017427ea Update CODEOWNERS 2019-02-19 19:41:45 -05:00
Radek Doulik 30799ff97f [profiler] Do not print that many new lines (#13060)
The `mono_profiler_printf` already adds `\n` char, so we don't need to
add them in most cases.

Before the fix the output of aot profiler with verbose enabled looked
like:

    02-19 10:50:02.877 22795 22815 I mono-prof: System.OutOfMemoryException:.ctor (string) 2
    02-19 10:50:02.877 22795 22815 I mono-prof:
    02-19 10:50:02.877 22795 22815 I mono-prof: System.SystemException:.ctor (string) 4
    02-19 10:50:02.877 22795 22815 I mono-prof:
    02-19 10:50:02.877 22795 22815 I mono-prof: System.Exception:.ctor (string) 6
    02-19 10:50:02.877 22795 22815 I mono-prof:
    02-19 10:50:02.877 22795 22815 I mono-prof: System.Exception:.cctor () 7
    02-19 10:50:02.877 22795 22815 I mono-prof:
    ...

The `usage ()`'s output should now look similar to other profilers
usage output.
2019-02-19 18:27:04 -05:00
Stephen Toub aff251e11c Move EventRegistrationToken to shared (dotnet/coreclr#22565)
* Move EventRegistrationToken to shared

* Address PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 00:18:55 +01:00
Stephen Toub e5f7fa3e67 Use RunContinuationsAsynchronously in SemaphoreSlim.WaitAsync (#22686)
SemaphoreSlim.Release shouldn't invoke arbitrary continuations as part of its invocation, so when it dequeues a task waiter and goes to complete it, rather than just calling TrySetResult, it queues the task to the thread pool to have TrySetResult invoked there.  Now that we have RunContinuationsAsynchronously, though, we can just use that functionality instead.  This has two main benefits:
1. We avoid queueing a work item entirely if there are no continuations from the task.  This might happen, for example, if the semaphore is released so quickly after waiting on it that the WaitAsync caller hasn't yet hooked up a continuation, in which case the await on the WaitAsync task will just see IsCompleted as true and continue running.
2. We avoid queueing a work item when the task represents a synchronous Wait, which happens if there's already a pending WaitAsync when Wait goes to block.  The main benefit here is avoiding potential thread pool starvation, if threads in the pool are blocked in such Waits, and previously another thread pool thread would have been needed to run the queued work item to complete the synchronous Wait.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-19 23:45:33 +01:00
Hugh Bellamy dc32ce591e Cleanup Calendars code (dotnet/coreclr#22582)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-19 23:45:33 +01:00
Martin Baulig 23762efca5 Add temporary workaround for internal StreamContent constructor. 2019-02-19 23:19:07 +01:00
Maxim Lipnin c890be00c9 use for loop to access item values and avoid InvalidCastException which occurs because VirtualDirectoryMappingCollection enumerator returns key and it's not expected 2019-02-19 21:08:02 +01:00
Fei Peng 1f33f3923a Optimize Vector128/256<T>.Get/WithElement (dotnet/coreclr#22353)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-19 17:08:46 +01:00
Johan Lorensson 187711df20 Enable runtime + corlib tests on CI for Windows x64 full AOT. (#13059) 2019-02-19 09:37:43 -05:00
Vlad Brezae c21c2df0af [interp] Kill stinarg opcodes (#13038)
* [interp] Extract some duplicated code

* [interp] Kill stinarg opcodes

Before we were reallocating the arguments in the current frame and had a stinarg opcode for copying each argument there. Access the arguments directly from the parent frame, to reduce call overhead. This can give up to 5-10% general speedup.
2019-02-19 08:40:00 -05:00
roozbehid af0bdab76d add missing typeforwardes in facades (#12694)
* add missing typeforwardes

* Bump API snapshot submodule
2019-02-19 13:38:17 +01:00
Zoltan Varga 9f9067094f [netcore] Fix GCHandles, the lowest bit is used by the GCHandle class to store information. 2019-02-19 10:51:51 +01:00
Marek Safar 2e88b48fde [mcs] Remove doc about CAS security 2019-02-19 10:14:48 +01:00
Zoltan Varga b8b2469380 [jit] Add a few more unsafe intrinsics. (#12971) 2019-02-19 02:27:40 -05:00
Katelyn Gadd 66092e0571 Update roslyn-binaries submodule to point to latest master revision (#12833)
This updates our roslyn submodule so that the new csc-dim is available.
2019-02-18 22:54:54 +01:00
Alexander Köplinger 1c26f21c0d Bump linker submodule to latest master (#13031)
* Bump linker submodule to latest master

* [csproj] Update project files
2019-02-18 14:02:34 +01:00
Phil Jaenke 8c185ed423 Remove leading . from script invocation (#13046)
The leading `.` in the script invocation causes the tests to fail on multiple platforms by causing the required argument to not be passed correctly resulting in bad output. Removal of the leading `.` ensures correct operation on all platforms.
2019-02-18 12:45:25 +01:00
Alexander Köplinger 602bdea385 Set executable bit for all .sh files in repo 2019-02-18 12:39:57 +01:00
bwadswor fe7c3d43e5 Correct access permissions to include "user execute" for run-msbuild.sh. (#13042)
Correct access permissions for run-msbuild.sh.  Adding "user execute" seems to fix the following build error.  With this change I'm able to build on windows in Cygwin.  without, I see the below error:

```
$ make -j4
(CDPATH="${ZSH_VERSION+.}:" && cd . && /bin/sh /cygdrive/c/mono/mono/missing autoheader)
rm -f stamp-h1
touch config.h.in
cd . && /bin/sh ./config.status config.h
config.status: creating config.h
config.status: config.h is unchanged
Git submodules updated successfully
make  all-recursive
make[1]: Entering directory '/cygdrive/c/mono/mono'
Making all in msvc
make[2]: Entering directory '/cygdrive/c/mono/mono/msvc'
Building Mono runtime using Visual Studio.
../msvc/run-msbuild.sh "build" "i686"
**/bin/sh: ../msvc/run-msbuild.sh: Permission denied**
make[2]: *** [Makefile:614: all-local] Error 126
make[2]: Leaving directory '/cygdrive/c/mono/mono/msvc'
make[1]: *** [Makefile:583: all-recursive] Error 1
make[1]: Leaving directory '/cygdrive/c/mono/mono'
make: *** [Makefile:513: all] Error 2
```
2019-02-18 12:34:29 +01:00
Zoltan Varga 77644b833e [netcore] EH work (#13041)
* [netcore] Switch to Debugger class from corlib.

* [netcore] Implement exception stack trace support.

* Address review comments.

* [netcore] Create a netcore specific version of Exception based on the refsource version.
2019-02-18 10:20:45 +01:00
Martin Baulig 099e003240 Add types supporting C# 8.0 Ranges. (#12841)
* Add types for C# 8.0 Ranges.

* Add workaround from @lewurm to fix the native crash.

* Fix compiler error test.

* [interp] guard span get_item intrinsic regarding its signature

* Cleanup sources and remove duplicates; thanks Egor!

* Bump API snapshot submodule

* [csproj] Update project files
2019-02-18 09:55:45 +01:00
Marek Safar ad62ab26b7 Merge pull request #13040 from marek-safar/build-fixes
[System.Private.CoreLib] Implement more APIs
2019-02-17 11:03:18 +01:00
Jan Kotas 003a626bba Avoid pulling in Lazy<T> during startup (dotnet/coreclr#22659)
Environment constructor runs on every startup path. Remove dependency on Lazy<T> from it.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-17 11:02:36 +01:00
Thays Grazia 194b82b8b0 If getter is not implemented in a property we don't want to show this property, in Vs the behaviour is the same. (#13033)
Fixes #12964
2019-02-16 11:48:00 -02:00
Marek Safar f0ca41c781 [System.Private.CoreLib] Implement more APIs 2019-02-16 00:47:18 +01:00
Tanner Gooding a12209bf52 Updating some local functions to be 'static' (captureless). (#22635)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-16 00:20:34 +01:00
Alexander Kyte 12b3dbcc38 [crash] Move dump_memory_around_ip after the native crash (#13021)
If someone jumps to a bogus address for some reason, this will
double-fault. On OSX, a double fault is often a hang.
2019-02-15 18:14:03 -05:00
Vlad Brezae b3839e4434 [interp] Fix unaligned crashes on arm (#12985)
* [interp] Fix unaligned access crashes on arm

strd instruction fails if the memory address is not word aligned.

Fixes corlib-xunit suite on arm.

* [interp] Fix warning
2019-02-16 00:06:00 +02:00
Alexander Köplinger d224a047e0 Revert "[Facades] Remove System.Drawing.Primitives from xammac_net_4_5_SUBDIRS"
This reverts commit 9c1fd50666.

This is wrong, net_4_x_SUBDIRS only includes common_deps_SUBDIRS, not common_SUBDIRS.
2019-02-15 20:39:33 +01:00
Ludovic Henry 42f7bff05b [ci] Fix Bitcode{+Interpter} on AArch64 (#13016) 2019-02-15 13:38:20 -05:00
Kenneth Pouncey ccfa653b48 [wasm][CI] Reactivate Chakra tests in CI (#13026)
- Chakra install fails: https://github.com/Microsoft/ChakraCore/issues/5945
2019-02-15 12:12:37 +01:00
Alexander Köplinger 9c1fd50666 [Facades] Remove System.Drawing.Primitives from xammac_net_4_5_SUBDIRS
It's already included in the common_SUBDIRS and confuses a build safeguard in xamarin-macios.
2019-02-15 12:03:40 +01:00
Marek Safar 34c3055a7c Move Interlocked 2019-02-15 09:25:26 +01:00
Tanner Gooding 884b4c2473 Fixing the number formatting code to only recognize 'R' for double/float. (#22613)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-15 09:25:26 +01:00
Marek Safar f2c8664ac1 Move Reflection.Emit Tokens to shared partition (dotnet/coreclr#22602)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-15 09:25:26 +01:00
monojenkins 4ee073da2a [bcl] Update BCL Linked Size 2019-02-15 08:34:51 +01:00
Grant 7e52c1973e Missed optimization from #22497
Signed-off-by: dotnet-bot <[email protected]>
2019-02-15 08:33:24 +01:00
Larry Ewing 7f0eaf39ca Add some blazor binaries to bcl-size-diff 2019-02-14 23:57:30 +01:00
Grant d91a227cba Consolidate implementation of Rotate and PopCount (dotnet/coreclr#22584)
* Perf: BitOps.LeadingZeroCount

* Remove redundant MSIL cast, conv.u8

* Use local functions for SoftwareFallback

* Target BIT32/64

Signed-off-by: dotnet-bot <[email protected]>
2019-02-14 23:00:36 +01:00
Marek Safar 8294fc0588 Remove local FrameworkEventSource 2019-02-14 22:47:06 +01:00
Marek Safar dbac2e4ffc Move FrameworkEventSource to shared partition (dotnet/coreclr#22507)
* Move FrameworkEventSource to shared partition

and remove unused code

* Remove more unused code

* Remove CA8001 suppress message

Signed-off-by: dotnet-bot <[email protected]>
2019-02-14 22:47:06 +01:00
Levi Broderick 776e2a84c3 Add Rune creation API from UTF-16 surrogate pair (dotnet/coreclr#22590)
Also brings in some perf improvements to existing char and UnicodeUtility APIs

Signed-off-by: dotnet-bot <[email protected]>
2019-02-14 22:47:06 +01:00
Egor Bogatov cf69b47259 NS2.1: System.IO, System.Reflection.Emit, etc (#12854)
* System.IO, System.Data

* lots of small ns21 improvements

* More changes (System.Reflection.Emit)

* Add IEquatable to S.R.Emit types

* bump corefx

* fix unix build

* more NS21 changes

* more changes

* bump corefx

* Fix failing tests (Sockets)

* bump corefx

* tmp workaround

* move DispatchProxyGenerator to net_4_x

* Bump API snapshot submodule

* [csproj] Update project files
2019-02-14 22:40:58 +01:00
Grant 572d9928c0 Perf: Consolidate implementation of LeadingZeroCount (dotnet/coreclr#22497)
* Perf: BitOps.LeadingZeroCount

* CR fix

* CR fixes

* Optimization

* Revert

* Confirmed fix

* Simplify

* Return int

* Fixes

* Simplify

* CR fixes

* CR fixes

* Fix unit failure on Linux-musl x64 Debug

* CR fixes

* CR fixes

* Cleanup

Signed-off-by: dotnet-bot <[email protected]>
2019-02-14 22:38:32 +01:00
Fei Peng 938477a7de Remove unnecessary ThrowIfUnsupportedType calls and definitions
Signed-off-by: dotnet-bot <[email protected]>
2019-02-14 22:38:32 +01:00
Ludovic Henry 1be2bbce16 [ci] Enable working Bitcode{+Interpreter} test suites (#12997) 2019-02-14 14:47:05 -05:00
Martin Baulig 5c754423f2 Pass X509Certificate2 to the certificate validator.
This makes us consistent with corefx; see also
https://github.com/dotnet/corefx/pull/35306.

Using `X509Certificate` has become a problem because the
`HttpClientHandler.ServerCertificateCustomValidationCallback`
callback takes an `X509Certificate2` parameter.
2019-02-14 18:27:13 +01:00
Maxim Lipnin 347af5d61f Bump ikdasm 2019-02-14 18:09:49 +01:00
Rolf Bjarne Kvinge 4fec79cc6a [tests] Add the BitcodeNotSupported category to tests exercising non-bitcode-compatible API. (#13007)
* [tests] Add the BitcodeNotSupported category to tests exercising non-bitcode-compatible API.

We have APIs that use exception filter clauses, and we don't support that when
compiling to bitcode.

So mark any tests exercising such API accordingly, so that we can skip those
tests when running tests on targets that use bitcode (watchOS).

* [tests] Use BitcodeNotSupported on applying profiles
2019-02-14 11:49:29 -05:00
Bernhard Urban 920a621367 [bitcode] round up value type size for slot calculation (#12992)
consider

```csharp
struct S3
{
    public ushort X;
    public ushort Y;
    public ushort Z;
}
```
this would be 3 * 2 = 6 bytes. Structs, however, are passed around as i32
arrays in LLVM IR between functions. Those, if such a struct is passed, are
split to int32 depending on the struct's size. The previous calulation was
wrongly reserving one such i32 slot instead of two for `S3` above.

Additionally increase slot size to i64 so that it aligns with a
slightly different ABI on arm64_32.
2019-02-14 14:56:45 +01:00
Alexander Köplinger 9e8317f877 [System.Net.Http] Improve HttpClientTest to use the retry http listener (#12994)
It was missed in https://github.com/mono/mono/pull/11829 so we were still manually
creating HttpListeners which are not hardened against "Address already in use".

Should fix/improve https://github.com/xamarin/maccore/issues/1407.
2019-02-14 11:32:12 +01:00
Zoltan Varga f1ccdc49a9 [runtime] Avoid depending on the layout of the ParameterInfo class in the runtime, netcore has a version with a different layout. (#12980) 2019-02-14 09:32:42 +01:00
Kenneth Pouncey f5084b594f Move the index accessors to TypedArray instead duplicating the logic. 2019-02-14 06:32:37 +01:00
Alexander Kyte 4b83678a4a [crash] Add more detailed reporting for exceptions (#12946)
* [crash] Add more detailed reporting for exceptions

This bumps the crash reporting file format to version 0.0.3.

* [crash] Fix exception stack walker to consider captured_traces

Previously we were missing these frames from the captured_traces fields
of MonoException and MonoStackTrace.
2019-02-13 23:27:17 -05:00
Ludovic Henry e0643e5ac7 [ci] Fix Linux x64 Bitcode job (#12970)
* [ci] Fix Linux x64 Bitcode job

* [ci] Add Bitcode+Interpreter job

* [ci] Improve output information when AOTting the BCL
2019-02-13 18:31:31 -05:00
Alexander Köplinger 1c2ef6a472 Mono.Native: Simplify checking for min-version
We don't need to do the replacement sed magic for the compat library,
it should just use whatever is passed in.
2019-02-13 23:36:07 +01:00
Alexander Köplinger ae507fc4c4 [corlib] Fix CustomAttributeDataTest.MethodIncludesDllImportAttributeData() on watch/tv
Bitcode requires that the native symbol exists.
Changed the pinvoke to something that exists in libc.
2019-02-13 23:35:52 +01:00
Marek Safar 689e9b2e03 Remove local SafeHandle version 2019-02-13 23:24:44 +01:00
Stephen Toub 85caf55c16 Move SafeHandle to managed code and shared (dotnet/coreclr#22564)
* Move SafeHandle to managed code and shared

This moves the implementation of SafeHandle from native code in the runtime to managed.  I used corert's implementation as a base, and reviewed it again against the existing native implementation, making a few tweaks to better match the existing semantics.

This should be a valid move because of the reduced goals around CERs, thread aborts, etc.

However, there are places in the runtime that access SafeHandle functionality via its native counterpart, so I kept the relevant pieces of the native code intact.  Most code will continue to use the managed APIs, but the runtime can continue calling into the native versions when needed.

* Address PR feedback

* Address PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-02-13 23:24:44 +01:00
Alexander Köplinger c81e675866 [wasm][ci] Disable ChakraCore tests"
Downloading ChakraCore is broken right now due to https://github.com/Microsoft/ChakraCore/issues/5945.
2019-02-13 23:06:12 +01:00
Michal Strehovský 268f9e41cc Annotate EventCounter as a relocated type (dotnet/corert#6990)
This moved to CoreLib and needs to be annotated as such for Project N.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-13 21:06:20 +01:00
Fei Peng 745499f724 Remove unnecessary ThrowIfUnsupportedType calls and definitions
Signed-off-by: dotnet-bot <[email protected]>
2019-02-13 20:57:02 +01:00
Ludovic Henry bbb71e04a0 [ci] Use testing_aot_full_interp for FullAOT+Interpreter+LLVM (#12976) 2019-02-13 09:56:32 -05:00
Kenneth Pouncey 49d1d1795b Add U : struct constraint on TypeArray. Addresses comment review. 2019-02-13 15:38:07 +01:00
Kenneth Pouncey 1f9533a777 Fix delegate call back. Causes memory access crash with AOT. 2019-02-13 14:45:04 +01:00
Aleksey Kliger (λgeek) 5f1a8e7764 [debug-helpers] Include custom modifiers in mono_type_get_desc (#12979)
* [debug-helpers] Include custom modifiers in mono_type_get_desc

* [mini] Print return type in MONO_METHOD_VERBOSE output
2019-02-13 08:38:16 -05:00
Zoltan Varga 2466c2fc79 [netcore] Implement Assembly/AssemblyName/Module.
For RuntimeAssembly, make a fork since the amount of changes is very big. For AssemblyName/RuntimeModule, use the corlib version with some
ifdefs.
2019-02-13 11:11:37 +01:00
Kenneth Pouncey d81f8c7370 Modification of sdk framework build to not include the initialisation of the Bindings as it is now automatic. 2019-02-13 10:46:46 +01:00
Kenneth Pouncey 6dc1f10af1 Add corebindings build module and inclusion AOT
- Conditional include of bindings depending on if  --nobindings is specified.
- Packager: AOT ninja build modifications.
   - Add corebindings build dependency
   - Add bindings_support.j build dependency
   - Remove dependency to add Bindings initialisation to build and mono_config.js
 - Modify runtime.js and runtime-tests.js to remove the bindings initialisation code.
2019-02-13 10:45:12 +01:00
Ludovic Henry a43f1d2909 [sdks] Add mac-{mac32,mac64} targets (#12959)
* [sdks] Add mac-{mac32,mac64} targets

* [sdks] Add configure-* and build-* for CI
2019-02-12 18:57:56 -05:00
Tarek Mahmoud Sayed 469b0a7a0f Index and Range updates (dotnet/coreclr#22331)
* Index and Range updates

* Address @mikedn  feedback

* Address Feedback

* more feedback

* Use Deconstruct in Range.GetOffsetAndLength

* Rename GetArrayRange to GetSubArray

* Temporary disable the old Corefx Range tests

* Return back the TimeSpan test disabling

* Fix Range jit test

* Exclude the jit test

* revert the changes in the jit Range test

* Address Suggested Feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-02-13 00:01:05 +01:00
Jan Kotas 781bebfdcb Fix CoreRT build breaks - Adjust resource name - Workaround C# compiler/analyzer bug
Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 23:36:22 +01:00
Marek Safar 3f5471a602 Remove local version of GCHandle 2019-02-12 21:19:29 +01:00
Stephen Toub 64a626fa87 Move GCHandle to shared (dotnet/coreclr#22499)
* Move GCHandle to shared

* Cache the handle in a local to make it easier for JIT to generate good code

* Rename m_handle to _handle to match the coding conventions

* Delete isPinned argument for GCHandleInternalCompareExchange

* Add fast path to GCHandle.Alloc/Free FCalls

* Disable outdated test

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 21:19:29 +01:00
Sung Yoon Whang c005351c61 Renaming RuntimeEventSource to NativeRuntimeEventSource (#22533)
* Renaming RuntimeEventSource to NativeRuntimeEventSource

* missed a couple of comments and XPlatEventLogger

* rename DotNETRuntimeEventSource.cs to NativeRuntimeEventSource.cs

* use condition= instead of ifdef

* removing ifdef from NativeRuntimeEventSource.cs

* Fix case for 'eventing' directory in csproj

* Fix unix builds

* This should fix unix build...

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 20:57:00 +01:00
Tanner Gooding 39f83e1925 Add extensions methods for several of the VectorXXX<T> helper methods (#22336)
* Moving several of the Vector128<T> instance methods to be extension methods.

* Moving several of the Vector256<T> instance methods to be extension methods.

* Moving several of the Vector64<T> instance methods to be extension methods.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 19:18:32 +01:00
Marek Safar d0c5bcff23 Fix the build 2019-02-12 18:37:19 +01:00
Marek Safar 27ea466b0b [System.Private.CoreLib] Clean up EqualityComparer 2019-02-12 18:37:19 +01:00
Thays Grazia 5f65ce9f7d [debugger] Reverting part of https://github.com/mono/mono/pull/12114 (#12950)
* [debugger] Reverting part of this commit https://github.com/mono/mono/pull/12114, removing this part the test ShouldCorrectlyStepOverOnExitFromArgsAfterStepInMethodParameter continues working and solve the regressions of 12881.
Inserted a new test that reproduces the regression.
Fixes #12881
2019-02-12 14:20:38 -02:00
Larry Ewing 2b9e5db153 Remove the logic that prepends a line in source references
Remove the hack that injected an extra line with the source
location now that we reference local sources when we can and
fix the Match logic so that it corrects for the difference
between pdbs and chrome breakpoints
2019-02-12 10:06:31 -06:00
Larry Ewing 2dcbeb5548 Use file: urls when when the files exist locally
Unknown schemes (dotnet:) are not well supported by all the
tools that support the chrome DevTools protocol so if the
file exists locally use a file: url rather than a dotnet:
url to reference it.
2019-02-12 10:06:31 -06:00
Larry Ewing 36d26498d4 Handle urlRegex breakpoint requests.
VisualStudio debug agents use urlRegex rather than url
when looking for breakpoint locations so add support for those
requests.
2019-02-12 10:06:31 -06:00
Larry Ewing 419646c960 VSCode expects the decription field to be populated for the variables display 2019-02-12 09:37:01 -06:00
Larry Ewing ce751cbe55 Make sure we add callFrameId so that the debugger populates locals 2019-02-12 09:37:01 -06:00
Michal Strehovský 52d6e18ea6 Ifdef out code that triggers UTC bug (dotnet/corert#7003)
This results in bad codegen on AMD64. I filed a bug internally; hopefully we can get a fix soon.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 16:17:04 +01:00
hamish-rose 412f75a1c5 Add new rounding modes to System.Math, System.MathF (dotnet/coreclr#20815)
* add new rounding modes to MidpointRounding.cs

new modes added to enum
implemented ToZero for double in Math.cs

* ToZero implementation

* implement double and float rounding modes

* updating rounding implementation

now round inline with DecCalc internal round implementation

* small bug fix

also replace var to make things obvious

* update implementation - floor/ceil

code review feedback

* review feedback

add comments, update MathF with floor/ceil

* code review feedback

 - fix comments
 - replace ifelse with switch
 - remove RoundingMode enum from DecCalc

* exclude outdated corefx test

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 16:12:49 +01:00
Larry Ewing 80c10f6307 Merge pull request #12952 from lewing/debugger-proxy-discovery
[Wasm] Proxy More of the DevTools protocol
2019-02-12 08:32:59 -06:00
Kenneth Pouncey 56d77dcce9 Remove unused code 2019-02-12 14:14:12 +01:00
Maxim Lipnin b4370f6e76 Update System.Data.Entity to handle new String overloads (#12680)
* Add new String overloads

* Remove some overloads with non-primitive types

* Remove IndexOf overloads with more than 1 argument

* Remove Trim() from TrimTranslator because CanonicalFunctionDefaultTranslator already supports it.

* Trim/TrimStart/TrimEnd: remove Char parameter overloads; add condition to support parameterless overloads.

* Remove unsupported Char overloads of Contains, IndexOf, StartWith and EndWith methods
2019-02-12 13:59:39 +01:00
Kenneth Pouncey fbaa3db2e0 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-02-12 13:30:53 +01:00
Kenneth Pouncey 58fe50e028 Add support for CopyTo
- ArraySegment
- primitive array
- memory address CopyTo (IntPtr, offset, count)
2019-02-12 13:16:16 +01:00
Kenneth Pouncey b1f7a22a8b Add CopyFrom implementation and support for
- ArraySegment
- support CopyFrom IntPtr, offset, count to marshal memory pointer from Heap to TypedArray
2019-02-12 10:32:20 +01:00
monojenkins 5374e7ef46 [csproj] Update project files 2019-02-12 08:52:42 +01:00
monojenkins e4303ac76f Bump API snapshot submodule 2019-02-12 08:52:42 +01:00
Alexander Köplinger 6474cf7b61 Bump cecil submodule 2019-02-12 08:52:42 +01:00
Zoltan Varga 19d705c69d [bcl] Restructure the Module classes to simplify netcore integration.
* Move all icalls to RuntimeModule.
* Make all icalls static and receive the module as an IntPtr.
* Remove some duplicate code between the RuntimeModule and ModuleBuilder classes.
2019-02-12 08:46:09 +01:00
Dotnet-GitSync-Bot 374f44ebe8 Mirror changes from mono/corert,coreclr (#12951)
* Make Module partial to allow additional changed for Mono

Signed-off-by: dotnet-bot <[email protected]>

* Move ConditionalWeakTable to shared (dotnet/coreclr#22531)

Leaves DependentHandle as being the runtime PAL

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 01:45:39 -05:00
Larry Ewing 85bf22730b Proxy More of the DevTools protocol
Much of the tooling around DevTools expects
actions under /json to return useful data
this adds adds some simple logic to proxy those
so that you can point tooling directly at the
proxied port and get responses you expect
2019-02-11 21:18:15 -06:00
Larry Ewing a51b475173 Merge pull request #12809 from lewing/wasm-debug-documentation
[WASM] debug documentation and sample updates
2019-02-11 20:08:54 -06:00
Marek Safar ac5ab1a7ef Use shared Volatile 2019-02-12 00:32:45 +01:00
Stephen Toub 9d136f9446 Move Volatile to shared (dotnet/coreclr#22523)
* Move Volatile to shared

This largely takes corert's implementation, which uses Unsafe.As and volatile fields.

We could investigate also removing the JIT's replacements subsequently.

* Add [Intrinsic] attributes

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 00:32:45 +01:00
Alexander Köplinger 6ca20e92b6 [ci] Bump timeout for corlib-xunit tests
See https://github.com/mono/mono/issues/12945
2019-02-11 20:34:04 +01:00
Kenneth Pouncey 17134ec2b6 Add support for CopyFrom
- Array, offset, count
- ArraySegment
2019-02-11 17:13:45 +01:00
Bernhard Urban aac567ff66 [ios] add crosswatch64_32 target (#12893)
* [ios] add crosswatch64_32 target

* fix gnu triple for wasm
2019-02-11 11:08:02 -05:00
Alexander Köplinger ff7fc7e93a [ci] Bump bockbuild to get fontconfig download url fix 2019-02-11 16:56:46 +01:00
Aleksey Kliger (λgeek) 95f31d0259 [runtime] Refactor pinvoke probing, part 2 (#12850)
* [marshal] Add emit_exception_for_error callback

* [runtime] MonoError-ize mono_lookup_pinvoke_call_internal

Two complications:

1. Marshalling needs to turn a MonoError into MethodBuilder instructions to
   emit an exception.
2. The public API uses two string to signal an error.  So we have to use
   a custom status struct to return the error code.

* [loader] Factor out library path transformations

* [marshal] Copy error msg in mono_mb_emit_exception_for_error

Add new mono_mb_stdrup to make a copy of a given string into the memory that
will live with the MethodBuilder's method.

* [interp] Callvirt of an icall should call the wrapper.

See pinvoke2.cs test_0_missing_virtual_pinvoke_method ()

You can have an icall override a virtual method:

    	public class T2 : T {
    		[MethodImplAttribute(MethodImplOptions.InternalCall)]
    		public override extern object MyClone ();
    	}

When the interpret saw this, it was setting up a child frame with the frame
method being the MonoMethod of the icall itself, not the wrapper.  But it was
executing the wrapper.  As a result if the wrapper body had a LDSTR in it, we
would hit the assertion in the MINT_LDSTR_TOKEN case where
frame->imethod->method->wrapper_type == MONO_WRAPPER_NONE is not allowed.

With this change the frame method is now the wrapper which has a correct
wrapper type.

* [loader] remove pinvoke_probe_transform_path do{}while(0) construct

take the line damage; make the code easier to understand.
2019-02-11 10:49:56 -05:00
Jonathan Chambers 7176289621 Grow StackSlotInfo array rather than asserting (#12829) 2019-02-11 09:28:48 -05:00
Johan Lorensson dad67f4760 Incorrect call to MONO_HANDLE_SETRAW causes random crash in sgen. (#12851)
mono_string_utf16_to_builder_copy incorrectly uses MONO_HANDLE_SETRAW to
update the chunkLength field with a string length. Since MONO_HANDLE_SETRAW
assumes the argument is a MonoObject reference this could lead to a dereference
and since the value is a string length, that dereference will lead to a crash.

The problem happens in mono_gc_wbarrier_set_arrayref_internal where vtable
is retrieved from value. The crash happens randomly since it is depending
on the object being moved out of the nursery + sgen_binary_protocol_wbarrier
not being eliminated.

Fix is to use MONO_HANDLE_SETVAL since the value is not a reference so no need
to trigger a write barrier.
2019-02-11 09:12:20 -05:00
Johan Lorensson 4ba6733438 Fix OP_GET_LAST_ERROR codegen on Windows x64 full AOT. (#12853)
Current codegen incorrectly read back last error when doing p/invoke for
full AOT. This caused many failed corlib tests ~600. It also
turns out that the test for set/get last error related to p/invoke that we
have in pinvoke2.exe, is not run for the full AOT profile, due to other tests
depending on none full AOT features. In order to make sure we run the test
and not regress, test has been moved into its own runtime tests, running as
part of full AOT testing.
2019-02-11 09:11:50 -05:00
Alexander Kyte 9531662837 [crash] Use safer invalid-free test (#12864)
When using the previous test, some memory unsafety was
observed. It's rather unrecoverable memory unsafety, as
it corrupts heap memory used by the sequence points, registered MERP
paths, jit info internals, and output string.

Crashes seen here: https://github.com/mono/mono/pull/12387 reproduce
with less than 100 iterations of this malloc test run as the stress
test.

```
(MonoJitInfoTable) $2 = {
  domain = 0x5050505050505050
  num_chunks = 1347440720
  num_valid = 1347440720
  chunks = {}
}
```

with

```
(lldb) p/x 1347440720
(int) $0 = 0x50505050
```

And sometimes the mono crash

```
(lldb) p *it
(SeqPointIterator) $3 = {
  seq_point = (il_offset = 0, native_offset = 0, flags = 0, next_offset = 0, next_len = 0)
  ptr = 0x5050505050505050 <no value available>
  begin = 0x5050505050505050 <no value available>
  end = 0x5050505050505064 <no value available>
  has_debug_data = 0
}
```

===

These do not reproduce when doing a double free of legally allocated
memory.

I think that the crash reporting tests aren't the place to check if the
OS allows for wild heap corruption when doing these things. I don't
think it's currently in scope for the runtime to do crash reporting
after it's internal metadata tables have been corrupted. They're the
source of truth for symbolication. We don't have many options to
validate and reparse them, unless we want to make this all very
heavyweight.
2019-02-11 09:11:11 -05:00
Johan Lorensson 1a3813e899 Fix errors in TimeZoneInfoTest on Windows full AOT using winaot profile. (#12852)
Fix errors in TimeZoneInfoTest on Windows full AOT using winaot profile.
2019-02-11 08:35:54 -05:00
Kenneth Pouncey 949f3f7125 Add implicit conversion to and from primitive array. 2019-02-11 13:49:30 +01:00
Kenneth Pouncey 0e1a202bbb Add Type Array CopyFrom support.
- This will copy a managed array from heap to the typed array memory.
2019-02-11 10:29:02 +01:00
Marek Safar d5147e88bb [System.Private.CoreLib] Add more APIs 2019-02-11 09:50:36 +01:00
Kenneth Pouncey 56021009aa Misspellings 2019-02-11 07:37:03 +01:00
Kenneth Pouncey 07bb573833 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-02-11 06:09:05 +01:00
Vlad Brezae 846eca0dbd [interp] Fix ldelema (#12903)
The ldelema IL instruction provided the element class while the Address intrinsic provided the array class.

Fixes https://github.com/xamarin/xamarin-macios/issues/5363
2019-02-11 01:09:06 +02:00
Calvin Buckley b2f590b599 Fix build and use System.Native on FreeBSD (#12921)
* Required includes for system headers to behave on FreeBSD

* System.Native on FreeBSD
2019-02-10 10:27:54 +01:00
Jan Kotas b98780c71b Fix casing of interop directories (dotnet/corert#6982)
Match convention introduced by https://github.com/dotnet/corefx/pull/35085

Signed-off-by: dotnet-bot <[email protected]>
2019-02-10 09:37:18 +01:00
Sung Yoon Whang 544c43d0d6 set up CoreLib to include EventCounter in build project (#22501)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-10 09:32:05 +01:00
Marek Safar ca418e412b [netcore] Update to the latest version 2019-02-09 17:31:41 +01:00
Alexander Köplinger 67f1926803 [ci] Fix windows job name in osx-package.groovy 2019-02-09 14:32:27 +01:00
Marek Safar 903b264c4f Move Array's SZGenericArrayEnumerator to shared partition (#22480)
* Move Array's SZGenericArrayEnumerator to shared partition

* Remove legacy comment

* Move all array enumerators to a new file

Signed-off-by: dotnet-bot <[email protected]>
2019-02-09 08:30:10 +01:00
monojenkins 1f330171a8 [bcl] Update BCL Linked Size 2019-02-09 08:27:25 +01:00
Sung Yoon Whang 3fa2c0511f move EventCounter to shared CoreLib (dotnet/corefx#35183)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-09 08:25:51 +01:00
Marek Safar 5f9b66db43 [System.Private.CoreLib] Add missing Array APIs 2019-02-09 08:23:04 +01:00
Grant 29942cfd80 BitOps.TrailingZeroCount has inconsistent software fallback (#22333)
Fix #22326

Signed-off-by: dotnet-bot <[email protected]>
2019-02-09 00:58:07 +01:00
Marek Safar 38550e117e [System.Private.CoreLib] Implement part of GCSettings 2019-02-09 00:08:20 +01:00
Marek Safar 54f35f6198 Clean up GCSettings temp version 2019-02-08 23:15:15 +01:00
Stephen Toub 4bb7d23683 Move GCSettings to shared (dotnet/coreclr#22483)
Mainly just type definitions and error handling that gets shared.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 23:15:15 +01:00
Ludovic Henry f804ffdd2c Merge pull request #12810 from lateralusX/lateralusX/fix-win-fullaot-runtime-tests
Fix Windows x64 full AOT runtime test failures.
2019-02-08 15:50:03 -05:00
Ludovic Henry 719668fda1 Merge pull request #12856 from migueldeicaza/registry-finalizer-fixed
[Registry] Prevent crash due to background thread facing problems in the file system
2019-02-08 15:44:23 -05:00
Ludovic Henry 2355e592dc [arm/bitcode] mark valuetype returns as such when dealing with pinvokes (#12894)
On armv7 our calling convention happens to be the same as the platform
one. However, when using a armv7 cross compiler to generate bitcode that
targets a different platform (e.g. arm64_32) the calling convention can
be different (e.g. on arm64_32, a return buffer must be passed via r8).
Thus, mark it properly for LLVM so it can generate correct code.
2019-02-08 15:38:00 -05:00
Bernhard Urban 8ad82bbfc1 [ios] link mono-native correctly (#12895)
Fixes this app startup issue

```
dyld: Library not loaded: /Users/lewurm/work/mono-watch4-ios-sdk/sdks/out/ios-target64-release/lib/libmono-native-unified.0.dylib
  Referenced from: /var/containers/Bundle/Application/9697C8F3-811C-4BF3-B1BC-1E6385673984/PublicStaging.app/test-Mono.Runtime.Tests
  Reason: image not found
Process 2269 exited with status = 0 (0x00000000) Terminated due to signal 6
```
2019-02-08 15:36:53 -05:00
Vlad Brezae b62cca8974 [interp] Remove some cknull uses (#12849)
* [interp] Avoid using MINT_CKNULL

Unnecessary overhead for this tiny instruction.

* [interp] Do null check for this before inlining

Otherwise we miss it.
2019-02-08 15:32:07 -05:00
Vlad Brezae edccda13d3 [interp] Add method to seq_points table after we finish registering it (#12902)
* [interp] Add method to seq_points table after we finish registering it

When adding a breakpoint (mono_de_set_breakpoint) we search in this table for seq_point information for the method. If we find the information we expect that the method is already compiled and has the metadata initialized when actually adding the breakpoint (set_bp_in_method). We were crashing if the jinfo field of the interp method was not yet initialized.

Fixes https://github.com/xamarin/xamarin-macios/issues/5381

* [interp] Move profiler callback when we are actually done

Just in case.
2019-02-08 15:29:07 -05:00
Jan Kotas b8ee1ca51f Update CoreRT with shared array implementation
Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 19:58:21 +01:00
Zoltan Varga f1dfd9c413 [llvmonly] Add a mini_llvmonly_throw_nullref_exception () jit icall to throw nullref exceptions, it occurs very frequently when explicit null checks are enabled. (#12883) 2019-02-08 13:06:11 -05:00
Zoltan Varga e14ef8a658 [corlib] Move the implementations of virtual methods from Assembly to RuntimeAssembly to ease netcore integration. (#12805)
* [corlib] Move the implementations of virtual methods from Assembly to RuntimeAssembly to ease netcore integration.

* [corlib] Move more code to RuntimeAssembly.

* [corlib] Move fields from Assembly to RuntimeAssembly/AssemblyBuilder.cs. Reduce the amount of fields visible to runtime code.

* Update serialization tests.

* Fix the MOBILE build.

* Bump API snapshot submodule
2019-02-08 13:05:54 -05:00
Zoltan Varga 83fc1456db [wasm] Add mixed tests to CI. (#12882)
* [wasm] Only dedup the assemblies which are actually AOTed in mixed mode.

* [wasm] Add mixed mode test targets.

* [wasm] Add mixed tests to CI.
2019-02-08 13:05:35 -05:00
Alexander Köplinger b01cfed2a4 [ci] Support building the OSX .pkg on private Jenkins 2019-02-08 17:18:41 +01:00
Alex Thibodeau d5dfaf6006 FIxing crash where a generic enum is passed into get_shared_type. Also added automated test to catch this scenario. (#12622) 2019-02-08 09:27:54 -05:00
Bernhard Urban b9c611e93c [arm64] encode offset within stack slot for r4 in gsharedvt descriptor (#12867)
Follow up fix for https://github.com/mono/mono/pull/11741

Fixes https://github.com/mono/mono/issues/12831
2019-02-08 12:28:29 +01:00
Bernhard Urban 63f4ee5540 [arm/bitcode] mark valuetype returns as such when dealing with pinvokes
On armv7 our calling convention happens to be the same as the platform
one. However, when using a armv7 cross compiler to generate bitcode that
targets a different platform (e.g. arm64_32) the calling convention can
be different (e.g. on arm64_32, a return buffer must be passed via r8).
Thus, mark it properly for LLVM so it can generate correct code.
2019-02-08 11:17:06 +01:00
Aleksey Kliger 972f29179d [sre] Handle null values in MarshalAsAttribute CustomAttributeBuilder
Normally strings are encoded as length-then-utf8 in ECMA-335.  But a null
String is encoded as just the byte 0xFF.

When we make a CustomAttributeBuilder for a MarshalAsAttribute and attach it to
some parameter we first encode the CAB as a byte blob and then decode it in
CAB.get_umarshal into a UnmanagedMarshal attribute.  But the decoding didn't
account for the possibility of null strings.

Fixes https://github.com/mono/mono/issues/12747
2019-02-08 10:56:08 +01:00
Marek Safar 49c0a9c2de Remove local DateTime 2019-02-08 10:37:29 +01:00
Marek Safar 9636096e3b Move DateTime for Unix to shared partition (dotnet/coreclr#22383)
* Move DateTime for Unix to shared partition

* Keep CoreCLR specific implementation

Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 10:37:29 +01:00
Marek Safar f4c9b79905 Use local Array version 2019-02-08 10:27:04 +01:00
Stephen Toub a4681c14d9 Fix CoreLib to include PasteArguments.Unix.cs correctly (#22453)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 10:27:04 +01:00
Marek Safar 2e267dfa80 Move Array to shared partition (dotnet/coreclr#22321)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 10:27:04 +01:00
Marek Safar 8608d281c6 Implement ManifestBasedResourceGroveler::GetNeutralResourcesLanguageAttribute (#22372)
* Implement ManifestBasedResourceGroveler::GetNeutralResourcesLanguageAttribute in shared managed code

* Remove native ::GetNeutralResourcesLanguage

Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 10:27:04 +01:00
Tarek Mahmoud Sayed ab717125aa Index and Range updates (dotnet/coreclr#22331)
* Index and Range updates

* Address @mikedn  feedback

* Address Feedback

* more feedback

* Use Deconstruct in Range.GetOffsetAndLength

* Rename GetArrayRange to GetSubArray

* Temporary disable the old Corefx Range tests

* Return back the TimeSpan test disabling

* Fix Range jit test

* Exclude the jit test

* revert the changes in the jit Range test

* Address Suggested Feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 10:27:04 +01:00
Bernhard Urban 33d6380103 [aot] interp flag on AOT images only on mscorlib required (#12838)
[aot] interp flag on AOT images only on mscorlib required

/cc @spouliot. This fixes `--interpreter=-all` on Xamarin.iOS.
2019-02-07 17:15:50 -05:00
Bernhard Urban 21c65aafc8 [ios] pass --enable-monotouch to cross compilers so icall defintions are visible to it (#12834)
This fixes a regression introduced by https://github.com/mono/mono/commit/5187b0bdaaff56936d697b0753dad51e7498991d

The AOT compiler wasn't aware of the icalls since they are guarded by `ENABLE_MONOTOUCH`. Passing `--enable-monotouch` to configure of the AOT compiler enables that define, so it can properly resolve those icalls. However, to avoid `zlib` dependency for the cross compilers, we stub
them out.
2019-02-07 20:26:42 +01:00
Alexander Kyte 0e65799c8e [runtime] Use temp folders for merp tests (#12830)
The 2018-10 lane seemed to be failing some tests because the merp-json-valid.exe test left behind the crash log file. I fixed that in this PR, but also move the tests into their separate folders so they can run at the same time safely.
2019-02-07 19:32:06 +01:00
Tanner Gooding 321e0b511f Fixing Utf8Formatter.Float to support all the same format specifiers as the utf16 formatter. (#22434)
* Fixing Utf8Formatter.Float to support all the same format specifiers as the utf16 formatter.

* Disabling some outdated CoreFX tests.

* Fixing TryFormatFloatingPoint to special-case format.IsDefault

Signed-off-by: dotnet-bot <[email protected]>
2019-02-07 18:47:19 +01:00
Stephen Toub 75a7b9601f Finish removing Environment from corefx
Signed-off-by: dotnet-bot <[email protected]>
2019-02-07 18:30:59 +01:00
Miguel de Icaza 39397b5e92 [Registry] Prevent crash due to background thread facing problems in the file system 2019-02-07 11:52:59 -05:00
Zoltan Varga b019ca4d5a [wasm] Fix icall table linking, generate one table per assembly. (#12840) 2019-02-07 11:44:11 -05:00
Vlad Brezae 33189ef31f [tests] Enable test suites on interpreter (#12806)
Seem to pass locally
2019-02-07 16:13:24 +02:00
Johan Lorensson bbe84c03fa Merge pull request #12811 from lateralusX/lateralusX/fix-win-fullaot-runtime-tests-toggleref
Fix issue where togglerefs might be incorrectly pinned by GC.
2019-02-07 02:59:45 -05:00
Kenneth Pouncey dedbbbf401 Fix error with bindings. 2019-02-07 07:09:08 +01:00
Aleksey Kliger (λgeek) d36f437f60 [runtime] Refactor pinvoke probing (#12795)
* [runtime] Mark mono_lookup_pinvoke_call external only

Runtime should use mono_lookup_pinvoke_call_internal

* [loader] Factor out helper functions from mono_lookup_pinvoke_call

Separate the logic for probing for a dynamic library module from the logic for
looking for a symbol inside the module.

* [loader] Factor out relative directory probing in pinvoke lookup
2019-02-06 20:50:32 -05:00
Zoltan Varga 9453281f0c [ci] Enable llvmonly+mixed tests on CI. (#12777) 2019-02-06 20:46:06 -05:00
Alexander Köplinger 004deafa3a [tests] Disable flaky block_guard_restore_aligment_on_exit.exe on Windows PRs
See https://github.com/mono/mono/issues/12839
2019-02-07 01:25:13 +01:00
Thays Grazia ada7c1b821 [wasm][debugger] Bug on attributes with value type string and content NULL (#12827)
* An attribute with a content that was a string null was creating two items in result json and it was throwing an exception in client side because it is expected a name and a value and not a name and two values.
2019-02-06 21:19:01 -02:00
Alexander Köplinger ea3d9b80b5 [corlib] Remove reflection-based Mono.Native test (#12828)
The managed linker removes the type embedded inside mscorlib and we don't want to whitelist it in linker xml since then it'd be kept for everyone.

Instead move the type to the test assembly and remove the reflection-based tests.
2019-02-06 22:47:19 +01:00
Miguel de Icaza b3eeb1667a [man] mono.1 - describe how to get the list of options 2019-02-06 15:52:19 -05:00
Alexander Köplinger b4c66a1d59 [mono-native] Remove accidentally added brotli.c file
It broke the iOS SDK build because of duplicated main().

See https://github.com/mono/mono/pull/12189
2019-02-06 20:50:50 +01:00
Alexander Köplinger 04c71af56a Extend mono-native minimum version magic to CPPFLAGS/CXXFLAGS (#12801)
We were only doing the -mmacosx-min-version replacement magic on
CFLAGS and LDFLAGS for mono-native-compat and -unified,
but we need to do the same for CPPFLAGS/CXXFLAGS too.

Fixes an issue where the libraries were targeting the wrong minimum OSX
version when built from xamarin-macios since they pass the minimum version
in CPPFLAGS instead of CFLAGS for OSX.
2019-02-06 19:07:58 +01:00
Martin Baulig 5c17c4cf31 Add support for async-streams (C# 8.0). (#12674)
Bring some new APIs from corefx master for async-streams (C# 8.0):

- `IAsyncDisposable`
- `IAsyncEnumerable`
- `IAsyncEnumerator`
- `AsyncIteratorMethodBuilder`
- `AsyncIteratorStateMachineAttribute`
- `ConfiguredAsyncDisposable`
- `ConfiguredCancelableAsyncEnumerable`
- `ManualResetValueTaskSourceCore`
- `TaskExtensions` (replacing our reference source version).

Minor changes to existing code:

- Add `ExecutionContext.ContextCallback<TState>(ref TState state)` delegate.
- Add `ExecutionContext.RunInternal<TState>` method.
- Uncomment `AsyncMethodBuilderCore.Start<TStateMachine>`.
- Add new `ThreadPool.QueueUserWorkItem<T>(Action<T>,T,bool)` and `UnsafeQueueUserWorkItem<T>(Action<T>,T,bool)` overloads.

New xUnit tests from CoreFX:

- `System.Threading.Tasks/tests/System.Runtime.CompilerServices/ConfiguredCancelableAsyncEnumerableTests.netcoreapp.cs`
- `System.Threading.Tasks.Extensions/tests/ManualResetValueTaskSourceTests.cs`
- `System.Threading.Tasks.Extensions/tests/ValueTaskTests.cs`
- `Common/tests/System/Threading/Tasks/Sources/ManualResetValueTaskSource.cs`
- `Common/tests/System/Threading/Tasks/Sources/ManualResetValueTaskSourceFactory.cs`
- `System.Threading.Tasks.Extensions/tests/AsyncValueTaskMethodBuilderTests.cs`
- `System.Threading.ThreadPool/tests/ThreadPoolTests.cs`
- `System.Threading.ThreadPool/tests/ThreadPoolTests.netcoreapp.cs` (partial due to missing `IThreadPoolWorkItem`)
2019-02-06 15:01:45 +01:00
Kenneth Pouncey fdc3d56c9b Typed Array Support - Initial commit
- Contains breaking changes
  - Remove NewArrayJS which is replaced with Array bidning.
- Add support for working with Typed Arrays, ArrayBuffer and Array.
-  Typed arrays supported

   - Int8Array 		| int8_t	| byte or SByte (signed byte)
   - Uint8Array		| uint8_t	| byte or Byte (unsigned byte)
   - Uint8ClampedArray| uint8_t	| byte or Byte (unsigned byte)
   - Int16Array		| int16_t	| short (signed short)
   - Uint16Array		| uint16_t	| ushort (unsigned short)
   - Int32Array		| int32_t	| int (signed integer)
   - Uint32Array		| uint32_t	| uint (unsigned integer)
   - Float32Array		| float		| float
   - Float64Array		| double	| double

- Split the bindings into separate file for easier support and to keep the driver program size down.
2019-02-06 14:52:30 +01:00
Thays Grazia e1602576d3 [wasm][debugger] Evaluate properties and generics. (#12782)
* [wasm][debugger] Evaluate properties and generics.
2019-02-06 09:39:00 -02:00
Alexander Köplinger aedc1ca38f [ci] Support Mono version 6.x in Windows .msi build 2019-02-06 11:47:02 +01:00
Vlad Brezae 7869333c52 [metadata] Fix dynamic delegate (#12762)
* [metadata] Decouple dynamic method signature from its delegate invoke wrapper

The invoke wrapper should not be referencing the signature because it will be freed once with the dynamic method. The wrapper can outlive the dynamic method, it is cached based on the signature.

Fixes crash on old IronJS benchmark with interpreter (which uses a lot of delegate wrappers, compared to jit)

* [interp] Add debug method for printing transformed code
2019-02-06 11:19:26 +01:00
Larry Ewing 5b44b5cbb8 Update README.md debugger instructions to match the current layout 2019-02-05 19:42:17 -06:00
Larry Ewing 1ea56466e4 Include mono-config.js produced by packager in debug.html 2019-02-05 19:41:37 -06:00
Larry Ewing d4251f42f4 Remove shell prompt from README.md to be consistent and improve cut and paste 2019-02-05 19:39:04 -06:00
Larry Ewing 879afec442 Merge pull request #12540 from jeromelaban/dev/jela/wasm-debugger-update
[WASM] Improve debugging support
2019-02-05 19:01:30 -06:00
Egor Bogatov 2f6104f163 [System.IO.Compression] Brotli from CoreFX (#12189)
Resolves https://github.com/mono/mono/issues/11431

I put the native impl to Mono.Native, but probably it should be in a separate lib (`libmono-native.0.dylib` before: **81kb**, after: **898kb**) if Linker is not able to trim it if it's not used.
Compiles and works on Windows (however, we don't build Mono.Native for Windows, but we can borrow `clrcompression.dll` from .net core) and macOS but requires changes in mono/corefx,

I disabled xunit tests as those need 50mb of test data.

PS: Brotli could be fully managed 😢 https://github.com/dotnet/corefxlab/issues/1673

C# ports:

- https://github.com/master131/BrotliSharpLib 
A quick benchmark (Compressing a 5mb file with max compression level=11)
Mono JIT: 25sec
Mono LLVM-AOT: 7.8sec
.NET Core 2.2: 6.8sec
.NET Core 3.0: 5.8sec
.NET Core's BrotliStream (with native lib): 3.5sec


- https://github.com/google/brotli/tree/master/csharp - official C# port. Based on Java sources, slow, outdated (2 years ago).
2019-02-06 00:25:19 +01:00
Martin Baulig 94f00fe796 Fix HttpClient on AIX (#12744). (#12771)
Define `PLATFORM_UNIX` in `mcs/build/platforms/unix.make` and make
`mcs/build/profiles/net_4_x.make` define `SOCKETSHTTPHANDLER=1` when set.
2019-02-05 22:41:43 +01:00
Alexander Köplinger fd71ea2fd3 [corlib] Disable GetFrames_AsyncCalls on mobile
See https://github.com/mono/mono/pull/12790
2019-02-05 21:33:56 +01:00
Michal Strehovský 399d14104a Fix ProjectN build breaks (dotnet/corert#6954)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-05 19:13:59 +01:00
lateralusX c432251142 Fix issue where togglerefs might be incorrectly pinned.
Due to current order, process togglerefs and then take current threads
stack could cause a problem where toogleref references might be left
in registers after native code process the list and those reference
would then be put into current thread context, incorrectly pinning the
toggleref, preventing it from being GC:ed. The problem was observed on
Windows (in debug build) running sgen-toggleref.exe runtime test since
the native compile of sgen_process_togglerefs used a register when
walking the list of togglerefs that was then not re-used until the
current threads stack was taken, causing incorrect pinning. This problem
could in theory happen on any platform depending on how sgen_process_togglerefs
would been compiled and what register will be used.

Fix is to take current threads context before walking the togglerefs to make
sure we are not getting managed references into registers as part of managing
the toggleref list in native code.
2019-02-05 18:37:05 +01:00
lateralusX ecc42a8410 Fix failure in catchfault_tail.exe due to stack overwrite in final handler.
Combination of Windows x64 ABI and the lack of not checking for fault handlers
in OP_START_HANDLER cause a hard to track stack corruption when combined with
tail calls. Fix is to make sure we also handle fault regions in handlers to
handle cases like the one exposed by catchfault_tail.exe test.
2019-02-05 18:34:20 +01:00
lateralusX dfa2fe6d2b Add better support to dynamically setup content of config.h in Windows MSVC builds.
When running tests on CI the runtime is configured from autogen.sh script.
When running fullaot there are a couple of features not supported so they are
disabled. The problem is that the MSVC Windows builds have its own winconfig.h
template, losing all the disabled features from configures config.h.

This commit adds support to detect the disable defines from configures config.h
if one exists. Since the complexity of this step increases the work previously
done in winsetup.bat has been moved into a msbuild target that is used from
both within VS build as well as winsetup.bat (there are a couple of other builds
using that bat file, so won't remove it).

The winconfig.h template we had is quite outdated compared to what’s generated
by configure. This commit also updates the winconfig.h to closer match what generated
for corresponding mingw build but keep all the Windows specific configurations
included in current version.
2019-02-05 18:34:20 +01:00
lateralusX c39e3e1200 Fix failing test under debug mode due to incorrect marshal alloc. 2019-02-05 18:34:20 +01:00
lateralusX 46e65d2a09 Fix process stress tests to not popup thousands of Windows.
Fix runtime test run to pickup working wrapper when running
with --enable-msvc but not setting MONO_EXECUTABLE.
2019-02-05 18:34:20 +01:00
Jo Shields 667925b987 Merge pull request #12794 from directhex/master
Bump version to 6.1.0
2019-02-05 11:26:56 -05:00
Jo Shields 1f77041f92 Bump version to 6.1.0 2019-02-05 09:42:19 -05:00
Marek Safar 29594b984c [corlib] Fix GetFrames_AsyncCalls test not to block 2019-02-05 13:09:36 +01:00
monojenkins ae99e720cd [csproj] Update project files 2019-02-05 13:08:33 +01:00
monojenkins b7fe8104e6 Bump API snapshot submodule 2019-02-05 13:08:33 +01:00
Egor Bogatov 4285787ece improve test 2019-02-05 13:08:33 +01:00
Egor Bogatov 5946cd6cb5 use CoreRT's CancellationToken and CancellationTokenSource 2019-02-05 13:08:33 +01:00
Egor Bogatov 56aab1437d add #if MONO to ref-source file 2019-02-05 13:08:33 +01:00
Egor Bogatov 3c9035442b Do not clone SyncronizationContext in EE 2019-02-05 13:08:33 +01:00
Martin Baulig afd4971208 "Ice Blue": Adding some "Connection Info" properties to SslStream. 2019-02-05 10:49:47 +01:00
Zoltan Varga 51287431af [netcore] Ongoing work. (#12750) 2019-02-05 10:34:31 +01:00
Ben Adams 45b6b640a4 Fix string.strlen (dotnet/coreclr#22397)
* Add explanation comment

Fixes #22393

Signed-off-by: dotnet-bot <[email protected]>
2019-02-05 10:29:49 +01:00
Marek Safar dc323ae290 Remove local SynchronizationContext 2019-02-05 10:20:12 +01:00
Marek Safar d2ee660406 Move SynchronizationContext to shared partition (dotnet/coreclr#22389)
* Move SynchronizationContext to shared partition

* Move WaitHelperNative to WaitHandle

Signed-off-by: dotnet-bot <[email protected]>
2019-02-05 10:20:12 +01:00
Vlad Brezae 63fc0ebdfa [interp] Add missing write barrier (#12772) 2019-02-05 09:30:33 +02:00
Jan Kotas 88a621524e More compact implementation of Marshal.GenerateProgIdForType (#22395)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-04 22:53:05 +01:00
Martin Baulig 721a437310 Remove internal WebRequest.RequestCallback to fix a compiler warning. 2019-02-04 22:52:38 +01:00
Thays Grazia 427cdf422e Disable test GetFrames_AsynsCalls for wasm only. (#12768) 2019-02-04 18:09:20 +01:00
Thays Grazia aa08555cfb [wasm][debugger] Add array inspection to the debugger. (#12733)
* [wasm][debugger] Evaluate array variables.

* Prefixing free_objref with mono_debugger_ to "document" that it's a debugger only function.
2019-02-04 10:32:40 -05:00
Aleksey Kliger (λgeek) f7fca0a8a2 [runtime] Switch to GC Unsafe in a few more external API functions (#12738)
* [runtime] Switch to GC Unsafe in mono_property_get_value

It's external only, so it should switch from GC Safe to GC Unsafe when called.

Addresses crash in https://github.com/mono/mono/issues/12724

* [runtime] Make mono_image_loaded external only

Also mono_image_loaded_full

Runtime should use mono_image_loaded_internal

* [runtime] Make mono_get_exception_argument_null external only
2019-02-04 16:10:49 +01:00
Jo Shields 4d9e8f58f8 Bump libgdiplus to mono-2018-12 branch tip 2019-02-04 15:14:14 +01:00
Damien Diederen 1cd74fa1cd [profiler] Avoid native crash with GUID-less assemblies
Without this patch, Mono crashes while writing AOT profiling data at
shutdown (when instructed to do so via --profile=aot:output=out.aotprof)
if any of the sampled methods belong to a dynamic image, which doesn't
have a GUID.

This happens with e.g. the DynamicProxyGenAssembly2 image:

> DynamicProxyGenAssembly2 is a temporary assembly built by mocking
> systems that use CastleProxy like Moq or NSubsitute. It is generated
> when the mock is needed and disposed of after the tests are finished.

(cf. https://stackoverflow.com/a/17179923)
2019-02-04 14:21:57 +01:00
Filip Navara 7d53edefa2 Remove code that was moved to System.Native (dotnet/corert#6932)
* Remove code that was already moved from System.Private.CoreLib.Native to System.Native.

* Move Interop files for System.Native to shared Interop directory.

* Add FeaturePortableThreadPool conditions to csproj files.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-04 14:18:40 +01:00
Mikhail Filippov 8a6d0028bd Use LoadFrom instead LoadFile for load logger type.
LoadFile lost assembly load-context. If the logger assembly has any dependencies placed in same folder logger can't load it. Main.cs using LoadFrom to load assembly but assembly already loaded in the cache after GetLoggerTypeName.
2019-02-04 14:14:53 +01:00
monojenkins 0ea6711572 [csproj] Update project files 2019-02-04 13:53:27 +01:00
monojenkins 3ad59586bf Bump API snapshot submodule 2019-02-04 13:53:27 +01:00
Egor Bogatov 7b0cd424db Copy refs from CoreFX 2019-02-04 13:53:27 +01:00
Marek Safar 81f5873758 [System.Private.CoreLib] Use local string version 2019-02-04 13:52:51 +01:00
Marek Safar bb5feb2579 [System.Private.CoreLib] Add Nullable runtime support 2019-02-04 09:44:40 +01:00
Michal Strehovský cc4c2b03d6 Throw the right exception when interface dispatch is ambiguous (#22295)
Throw the approved exception per dotnet/corefx#34124.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-03 22:04:43 +01:00
Filip Navara 4b88f5c167 Move Interop.GetTimestamp.cs to shared CoreLib partition. (#35031)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-03 21:34:31 +01:00
Marek Safar 03f07724b3 [System.Private.CoreLib] Fix the build 2019-02-02 23:05:22 +01:00
Zoltan Varga 6bc1e59d69 [runtime] Rename more MonoX->RuntimeX classes. (#12732) 2019-02-02 21:36:49 +01:00
Stephen Toub d0c54c546a Avoid delegate/work item allocations when setting async continuation (#22373)
When awaiting a task, there's a race between seeing whether the task has completed (in which case we just continue running synchronously), finding the task hasn't completed (in which case we hook up a continuation), and then by the time we try to hook up the continuation finding the task has already completed.  In that final case, we don't want to just execute the callback synchronously, as we risk a stack dive, so we queue it.  That queueing currently entails two allocations in the common case: one for the work item object, and one for the Action delegate we force into existence for the state machine box's MoveNext method (in the common case it's now never allocated because you only await Tasks and ValueTasks known to the runtime, which bypasses its creation).  We can instead just queue the box itself, and avoid both allocations.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-02 21:24:16 +01:00
Jan Kotas 3496691706 Rename ResourceManager fields to follow conventions (dotnet/coreclr#22371)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-02 20:02:34 +01:00
Lee Culver cab519ca07 Add back missing stack frames to mono MERP reports
Changeset https://github.com/mono/mono/commit/e1461ebc855977667f71d1804fd96eed2a155aff
introduced a regression where only the topmost frame of managed crashes are reported.

This change adds back the missing stack frames.
2019-02-02 15:18:28 +01:00
Marek Safar a7277849e7 Remove Mono implementation 2019-02-02 09:54:49 +01:00
Marek Safar 89c8d135eb Move Marshal::UnsafeAddrOfPinnedArrayElement to shared partition (#22359)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-02 09:54:49 +01:00
monojenkins 15e7ec70de [bcl] Update BCL Linked Size 2019-02-02 09:44:42 +01:00
Alexander Köplinger 2c8fe4fdc2 [bcl] Use delaysign for nunit/nunitlite
Otherwise mcs won't build it.
2019-02-02 01:17:59 +01:00
Marek Safar 598426a7ae Remove local ResourceManager 2019-02-02 00:20:35 +01:00
Stephen Toub b2226867ae Remove stale warning 420 pragmas (dotnet/coreclr#22352)
It used to be that the CS0420 warning ("a reference to a volatile field will not be treated as volatile") would fire when a volatile was used with an Interlocked.* operation.  That warning was unnecessary, as Interlocked.* would itself provide the relevant barriers, and these functions were special cased in Roslyn a long time ago.  But there are still lots of places where pragmas disabling the warning have stuck around.  I'm deleting them all.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-02 00:20:35 +01:00
Filip Navara 21fca52b3d Move ResourceManager to shared CoreLib. (dotnet/coreclr#22249)
* Move ResourceManager to shared CoreLib.

* Split UAP code out of ResourceManager.cs into separate files.

* Remove ResourceManager.NonUap.cs.

* Do not access internal field (CoreRT build fix).

* Fix non-Windows builds (CoreRT).

* Remove obsolete Debug code.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-02 00:20:35 +01:00
Alexander Köplinger 31e170fd3e [bcl] Actually fix the nunit/nunitlite assembly identity (#12743)
The solution from https://github.com/mono/mono/pull/12725 doesn't fully work
since e.g. gacutil seems to verify the strong name.

Instead follow what we do for other keys where we don't have the private key:
add them to the machine.config pubTokenMapping list.
2019-02-01 23:33:36 +01:00
Alexander Köplinger 260cc5411d Fix tarball build 2019-02-01 23:15:00 +01:00
Maxim Lipnin cd2d903518 Avoid recursive extracting redundant frames from captured traces. 2019-02-01 23:05:25 +01:00
Tanner Gooding 40eb410e73 Update the double/float formatters to return the shortest roundtrippable string. (#22040)
* Updating Number.Formatting to always compute a round-trippable number by default.

* Adding a third-party notice entry for the Grisu3 reference implementation

* Fixing up the Grisu3 algorithm to better match the reference implementation (including comments, etc)

* Porting the Grisu3 implementation that generates the shortest roundtrippable sequence.

* Updating the Dragon4 algorithm to support printing the shortest roundtrippable string.

* Fixing the double/float formatters to ignore precision specifiers for 'R'

* Fixing the double/float formatters to handle +0.0 and -0.0

* Fix the casing of `point` in THIRD-PARTY-NOTICES

Co-Authored-By: tannergooding <[email protected]>

* Fixing the double/float formatting code to consider a precision specifier of 0 to be the same as default.

* Fixing the double/float formatter so that nMaxDigits is set appropriately.

* Changing the double/float formatting logic to account for the format when determining the correct precision to request.

* Updating the double/float formatter to take the format specifier into account when determining the number of digits to request.

* Fixing the double/float formatting code to continue handling zero correctly.

* Disabling some outdated CoreFX tests.

* Responding to various feedback from the PR

Signed-off-by: dotnet-bot <[email protected]>
2019-02-01 22:28:08 +01:00
Alexander Köplinger 2d715b1af2 Fix tarball build 2019-02-01 20:59:54 +01:00
Alexander Köplinger acc902614e [bcl] Fix assembly identity of nunit/nunitlite (#12725)
* [bcl] Fix assembly identity of nunit/nunitlite

The new strong name key added in https://github.com/mono/mono/commit/acaa73b7026897f7e83a101a9bc331476b5ed169
changed the assembly identity which we can't do for shipping libraries.

Given that the old .snk is invalid (see https://github.com/dotnet/roslyn/issues/32502),
we just sign with the extracted public key and /publicsign.

For MCS_MODE builds we instead use the mono.snk since mcs doesn't support /publicsign
and we don't really care about having the correct identity there.

* [csproj] Update project files
2019-02-01 20:58:54 +01:00
Johan Lorensson 7710b4c099 Add support for Windows x64 winaot, winaot_llvm builds/tests on CI. (#12601)
Add support for building Windows x64 fullaot version of winaot profile
that can be run on CI. Initial changes also add execution of mini regression
tests on CI. More tests will be added going forward and when having full
pass rate.

Add support for building Windows x64 fullaot+llvm version of winaot profile
that can be run on CI. Initial changes also add execution of mini regression
tests on CI. More tests will be added going forward and when having full
pass rate.

In order to get deterministic build results and working build on CI, we need
to setup a correct build environment for the MSVC builds. Since MSVC build is
currently run from cygwin, there are environment problems, both general
but also in our CI environment, since we add cygwin bin folder to system path
(needed by Jenkins plugin). When running more complex cmake builds like
BTLS and LLVM, this will cause problems picking up incorrect tools,
failing builds on CI.

Another problem is the AOT compilation using MSVC toolchain. In the
past CI used some "hard coded paths" to make sure clang.exe and link.exe was found.
This is not optimal and won't work when including LLVM as part of full AOT since
link.exe will need access to more of the full build environment setup by VS
development environments (like platform libraries).

In order to get a better build environment on CI this commit includes and enhance
a couple of build scripts used to run msbuild.exe and mono-sgen.exe (as AOT compiler)
in a VS development environment, isolate that build process from cygwin environment.

The build scripts will locate installed VS tooling, VS2015 build tools or VS dev env,
VS2017 build tools or VS dev env and use corresponding development environment
scripts as part of running msbuild.exe and mono-sgen.exe in AOT mode.

In order to make sure mono-sgen.exe as AOT compiler is run through these scripts
an additional environment variable MONO_EXECUTABLE_WRAPPER is introduced and used
in mono-wrapper when set. Without this indirection there will be problems on CI
tests since the environment is using MONO_EXECUTABLE and pass that into for example
test driver that run child processes of mono-sgen.exe, meaning that we can't
use scripts for MONO_EXECUTABLE, but splitting the MONO_EXECUTABLE to represent
mono runtime and have a MONO_EXECUTABLE_WRAPPER that could be a launch script
solves this issue.

This commit also includes several smaller fixes made to the generic
fullaot build infrastructure.

Fix additional msbuild arguments.

Add Mono.SIMD assembly to winaot profile.

Run msbuild.exe as part of .bat file.
2019-02-01 11:54:45 -05:00
Marek Habersack dc1cdb9983 [bcl] Fix possible deadlock race in CSharpCodeGenerator (#12685)
`CSharpCodeGenerator` runs a compiler while redirecting its standard error and
standard output streams for further reporting. However, in doing that it fails
to read the standard output data completely and also fails to properly wait for
the standard error output to complete. Depending on environment it may lead to
the process using `CSharpCodeGenerator` hanging while the process has already
exited but there still is data to be read from standard output and standard
error.

This commit changes the code to an implementation of reading standard error and output
that makes sure all the data is read before the process is closed.

The hope is that it may fix some of the timeouts/hangs we see on the
Xamarin.Android build bots as a portion of them hangs in test that use the
code generator.
2019-02-01 15:14:28 +01:00
Alexander Köplinger a1973e5cae Bump api-snapshot 2019-02-01 14:13:38 +01:00
Martin Baulig 2f411750ac "Imperial Red": Bring HttpClient from CoreFx (#11906)
This brings `System.Net.Http` from CoreFx.

It is currently only enabled on Desktop Mac and Linux; Mobile is coming shortly.
2019-02-01 14:09:30 +01:00
Marek Safar af70768885 Merge pull request #12704 from lewurm/arm-ios-epsilon-workaround
[arm/ios] workaround for faulty vcmp.f64 insn
2019-02-01 14:05:06 +01:00
Bernhard Urban cd937eaaa0 Bump corert
Commit list for mono/corert:

* mono/corert@1b7d4a1e4 [Number] make double 0.0 cmp more portable (#30)

Diff: https://github.com/mono/corert/compare/c4ae51646152de0af32b2c85538b6e7317faa7f8...1b7d4a1e4bd79305905338827cc41eb8303364f0
2019-02-01 14:04:45 +01:00
monojenkins ec2b56cc78 [csproj] Update project files 2019-02-01 10:56:46 +01:00
Zoltan Varga 1c1e0b1bad [runtime] Rename most System.Reflection.MonoX classes to RuntimeX for consistency with coreclr. 2019-02-01 10:56:46 +01:00
Thays Grazia 257efc6374 [Tailcall] [arm] [jit] Fix moving tailcall parameters. (#12701)
* When moving parameters for tailcall, first copy the parameters using ARMREG_IP and after that get destination in ARMREG_IP, then it's not necessary the PUSH and POP to SP nor the saved_ip_offset.
Fixes #11489

* Removing unused variable.
2019-02-01 10:01:32 +01:00
Alexis Christoforides 8f5cef9364 [corlib] Import System.IO.File from CoreFX (#12000)
Contributes to #7246
2019-02-01 09:48:09 +01:00
Tanner Gooding 472269a1cf Fixing a GC hole in Number.BigInteger (dotnet/coreclr#22334)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-01 09:25:03 +01:00
Michal Strehovský d5a924a9dd Annotate types moved from S.R.Extensions
Testing how much hate this is going to bring me.

These annotations let ProjectN deal with the fact that we now have two
definitions of System.Environment in the system. This is needed as long
as Project N is stuck on 2.1-level version of the framework.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-01 09:25:03 +01:00
Stephen Toub 86406319d2 Replace several Nullable<T>.Value with .GetValueOrDefault() (#22297)
The former does extra work that the latter doesn't do, and they're equivalent when we know it contains a value, such as immediately after a HasValue check.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-01 09:09:37 +01:00
monojenkins 65e51b26c3 [bcl] Update BCL Linked Size 2019-02-01 09:09:00 +01:00
Vlad Brezae 6bab31e4c1 [marshal] Optimize clearing of entries for method (#12681)
Fixes dynamic-method-churn.exe timeouts, which was hanging on arm because the finalizer thread was hanging from taking too long to clear these hashtable entries.
2019-01-31 21:48:10 -05:00
Zoltan Varga 7517529b62 [netcore] Add back corlib version check. (#12702) 2019-02-01 01:43:35 +01:00
Zoltan Varga b8b527c7ca [netcore] Ongoing work. (#12697)
* [runtime] Fix icall ordering.

* [netcore] Disable dllmap for netcore for now.

* [netcore] Disable loading some threadpool types which don't exist in netcore.

* [netcore] Disable Mono.Native.
2019-01-31 18:50:39 -05:00
Andrew Au f086f55c17 AsyncSteppingFix - Eagerly initialize the AsyncStateMachineBox to avoid expression evaluation in ProjectN async stepping.
[tfs-changeset: 1732745]

Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 21:05:39 +01:00
Michal Strehovský 1139b8e47a Fix ProjectN build breaks (dotnet/corert#6924)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 19:25:56 +01:00
Alexander Köplinger 78d2492ef6 [bcl] Add Mono.CSharp back to xammac profile
It was removed in https://github.com/mono/mono/commit/96af472795496ad32768d113b1cb42a9d3cdcbcf but xammac does need it still.
2019-01-31 18:19:58 +01:00
Zoltan Varga 57fda1a647 [llvmonly] Make direct calls to icalls/icall wrappers. (#12693)
* [runtime] Improve mono_print_ji ().

* [llvmonly] Add a few more preinited got slots. Avoid emitting TLS_TRAMP preinited got slots in llvmonly mode.

* [aot] Simplify the mangled name of icall wrappers.

* [llvmonly] Make direct calls to icalls/icall wrappers in llvmonly+static mode.

* [aot] Disable some dedup logging which is always 0.

* Fix an strstr call.
2019-01-31 11:51:16 -05:00
Bernhard Urban 719117f9d7 [arm/ios] workaround for faulty vcmp.f64 insn
Fixes https://github.com/mono/mono/issues/11965
2019-01-31 17:02:17 +01:00
Alexander Köplinger a2abcc9a2f [System] Skip DefaultValueAttributeTest.Bug_12362() on xammac 4.5 too 2019-01-31 16:57:25 +01:00
Stephen Toub 554ff45da9 Replace Environment.s_macOS with use of PLATFORM_OSX
Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 16:38:51 +01:00
Stephen Toub 05956b9db7 Adapt corert to Environment moving from corefx
Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 16:38:51 +01:00
Alexis Christoforides ea55c54fe9 [xammac_net_4_5] Use CoreFX System.IO 2019-01-31 13:48:16 +01:00
Zoltan Varga 6ec5e3a4cf [corlib] Fix the linker descriptors for the SRE classes.
Preserve the ModuleBuilder.RuntimeResolve () method using a PreserveDependency attribute.
Remove nonexistent methods.
2019-01-31 13:47:25 +01:00
Marek Safar c7cb61a9a6 Remove GetSystemMaxDBCSCharSize implementation 2019-01-31 08:41:41 +01:00
Marek Safar f3ef35c779 Add managed implementation of GetSystemMaxDBCSCharSize (#22290)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 08:41:41 +01:00
Tanner Gooding 68606a1c30 Reverting "Fixing up the UTF8Formatter and some tests to properly handle -0.0" (#22300)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 08:33:33 +01:00
Marek Safar 1b09a26710 Implement Environment 2019-01-30 23:28:37 +01:00
Stephen Toub 8eeffb8628 Switch CoreLib over to using shared Environment from corefx (#22106)
This requires merging/adapting the implementation with EnvironmentAugments (which goes away completely), the shared files, what corert has, etc.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 23:28:37 +01:00
Jonathan Chambers 115c196575 Implement marshaling for generic struct fields (#12660) 2019-01-30 13:57:03 -05:00
Johan Lorensson 1350f7a77a Windows support to abort blocking system calls. (#12654)
* Fix race condtion in socket altertable wait implementation on Windows.

* Add support to abort blocking Windows mono_w32file_read/write methods.
2019-01-30 13:53:44 -05:00
Vlad Brezae 2f92606f1f [tests] Disable oldgen stress on interp (#12682)
[tests] Disable oldgen stress on interp
2019-01-30 12:36:06 -05:00
Vlad Brezae e461679612 [interp] Add support for break on method entry (#12651)
[interp] Add support for break on method entry

When using --break. We need to have a breakpoint set from debugger in mono_break.
2019-01-30 11:36:24 -05:00
Rolf Bjarne Kvinge 29b163f41c Fix leak if mono_assembly_setrootdir is called multiple times. (#12648)
Fix leak if mono_assembly_setrootdir is called multiple times.

Fix leak if mono_assembly_setrootdir is called multiple times by freeing the
previously stored value.




<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2019-01-30 10:16:01 -05:00
Vlad Brezae efac4c16ed [sgen] Logging for objects kept alive from ephemerons (#12650) 2019-01-30 16:17:08 +02:00
Rolf Bjarne Kvinge c9583047e8 Fix leak if mono_set_config_dir is called multiple times. (#12647)
Fix leak if mono_set_config_dir is called multiple times.

Fix leak if mono_set_config_dir is called multiple times by freeing the
previously stored value.




<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2019-01-30 09:15:57 -05:00
Michal Strehovský 434ec4110d Fix namespace of the AmbiguousImplementationException (#22291)
Moving to the namespace that was approved in dotnet/corefx#34124.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 13:48:02 +01:00
Jonathan Chambers ea95b18bde Throw ArgumentNullException if null method is passed to delegate constructor via invoke. (#12668)
Throw ArgumentNullException if null method is passed to delegate cons…

…tructor via invoke.

Fixes Unity issue: https://issuetracker.unity3d.com/issues/editor-crashes-with-g-logv-when-entering-play-mode-with-active-flowcanvas-script
2019-01-30 05:06:20 -05:00
monojenkins 3730afd464 [bcl] Update BCL Linked Size 2019-01-30 09:46:03 +01:00
Markus Kitsinger 63e512d133 Add AmbiguousImplementationException (dotnet/coreclr#22280)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 09:33:07 +01:00
Markus Kitsinger 3850bce0f0 Do not cache error string in SerializationException (dotnet/coreclr#22281)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 09:33:07 +01:00
Marek Safar 3322b33f0d Remove Mono implementation 2019-01-30 09:30:24 +01:00
Marek Safar 167e79290f Move Marshal::StringTo* methods to shared partition (dotnet/coreclr#22266)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 09:30:24 +01:00
Tanner Gooding fb1a589aea Fixing several of the HWIntrinsic SoftwareFallback functions to be captureless (#22263)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 09:30:24 +01:00
Michal Strehovský 3d17e982c1 Recover some of the size lost with AsyncMethodBuilder/Task unification (#6913)
When we unified the implementations of these across all of our runtimes, we lost all size optimizations people have been doing on the Project N side over the past six years.

This restores a bit of the loss. For one sample app with lots of async usage, this removes 2.1 MB of generic instantiations.

There is more we can do, but I can't spend time on that right now. These two things jumped out on me when I was looking at it back in December and were an easy fix I wanted to do for a while.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 09:30:24 +01:00
Zoltan Varga 4799e263a9 [aot] Size optimizations. (#12631)
* [gshared] Make mono_method_lookup_or_register_info () static, its only used in mini-generic-shared.c. Simplify callers.

* [aot] Optimize the encoding/decoding of MonoJumpInfoRgctxEntry.

Previously, all entries were associated with a method, but thats only needed for entries which have
is_mrgctx set, the rest can be associated with a class. Also, emit the encoding of methods/classes
only once, then refer to the them using a blob offset.

* [aot] Optimize the encoding of generic contexts by emitting every ginst only once.

* [aot] Add a MONO_AOT_METHOD_FLAG_HAS_PATCHES flag to avoid having to write the number of patches if its 0.

* [aot] Add a preinited got slot for MONO_PATCH_INFO_GC_SAFE_POINT_FLAG, fix the equality test.
2019-01-29 16:10:51 -05:00
Alexander Köplinger af2b7fec45 [utils] Add mono-errno.h to EXTRA_DIST
It was missed in https://github.com/mono/mono/pull/12082
2019-01-29 21:30:15 +01:00
Thays Grazia 4c09d46388 [Wasm][Debugger] Object inspection. (#12655)
* [Wasm][Debugger] Object inspection.

* Changind  indention formatting.
2019-01-29 10:37:08 -05:00
Kenneth Pouncey 51e3be76db [wasm] Wasm Websocket support (#12615)
* [wasm] Fix crash with delegates.

Internally the javascript bridge support uses `System.Delegate` and `System.Delegate.DynamicInvoke` to support delegate callbacks.  The linker, when executed over the assemblies, does not know about this code coverage and will strip out `System.Delegate.DynamicInvoke`.

To fix this:

- Add reference to `System.Delegate.DynamicInvoke` to the `WebAssembly.Bindings` linker xml file so the linker knows not to strip the code.
- Add detailed error messages in case something else goes wrong so the crash is not so cryptic.

* [wasm] WebSocket support initial commit.

- Connect to socket
- Basic Send and Receive support for Text and Binary - Needs work.
- Close socket.

* Add nuget packaging for build tools sdk

* Add Not Implemented Exceptions to the ClientWebSocketOptions implementation.

- The browser websocket specification does not provide for referencing the underlying http parameters.
- KeepAliveInterval - The browser websocket implementation implements the PING/PONG implementation and does not provide a mechanism via the websocket API.

* Remove validattion for keepalive as it is not implemented.

* a couple more Not Implemented Exceptions for WebSocketOptions

* Change to PlatformNotSupportedException.

* ProjectReference instead of assembly.

* Add websockets assembly to sdk build

* Add WebAssembly.Net.Websockets to packager.

- Treat as core for AOT linker.  This should be linked out but the linker but will appear in the loaded assembly list.
- Make sure it is imported as part of the non AOT build.

* Cleanup code.

* Add WebAssembly.Net.WebSockets assemblies to package
2019-01-29 10:35:33 -05:00
Katelyn Gadd 3704221361 Fix pipes not being enabled in all relevant versions of the build profile 2019-01-29 11:41:04 +01:00
Egor Bogatov cd69f587dc [corlib] TimeZoneInfo from corefx (#11500)
Not yet enabled for mobile, build and basic profiles.
Doesn't require ICU dependency, also I created a small PR for dotnet/coreclr to improve TimeZoneInfo.DisplayName on unix: https://github.com/dotnet/coreclr/pull/20728

Part of #7737
2019-01-29 11:34:00 +01:00
Marek Safar 1f4a0965cc Add Marshal ansi conversion to shared partition (dotnet/coreclr#22243)
* Add Marshal ansi conversion to shared partition

* Ignore bestFit/throwOnUnmappableChar on Unix

* Use same assert in StringToAnsiString

* wideCharLen parameter rename

Signed-off-by: dotnet-bot <[email protected]>
2019-01-29 09:15:21 +01:00
Filip Navara 30b930a0fe Add sample from issue #12402. 2019-01-28 23:43:13 +01:00
DasSkelett cd814981ea Take text alignment for LinkLabels into account (#12643)
<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
## Problem
`LinkLabels` ignore the text alignment for rendering the "hitbox" and the text color (= the `LinkArea`), and the focus rectangle. Also every text behind the end of this LinkArea/focus rectangle region is not painted at all.
This becomes visible if `AutoSize = false` and the `Size` is bigger than the text would need,
and if the text alignment is anything different than `TopLeft`.

## Cause
I think this is because the `piece.regions` are only translated regarding the padding, but neglecting the text alignment.

## Solution
Calculate the offset due to alignment and add it to the translation in `LinkLabel.CreateLinkPieces ()`

Fixes #12402 

## One more problem:
~Right now, a very tiny bit at the end of the label is still cut off (see my zipped and attached comparison pictures). Maybe `GetBounds ()` returns a value little bit smaller than it should be.
Can someone help?~

Also, maybe I took the wrong approach to this issue, but I don't know the inner mechanisms of mono.
So feel free to either advise me to change something, or change it yourself(s) :)
2019-01-28 23:30:10 +01:00
Mike Krüger 085ddcccb5 Fixes VS4Mac Issue #6898 (#12432)
https://github.com/mono/monodevelop/issues/6898

Not sure if it's the root of the problem but it surely fixes the dead lock on my machine.
2019-01-28 16:30:40 -05:00
Aleksey Kliger (λgeek) 1ec822976b [cxx] Set CXXLD and CCLD in configure (#12625)
* [cxx] Set CCLD and CXXLD for final linking

Essentialy bypass automake's automatic linker selection based on _SOURCES file
extensions.

The issue:
  1. Right now we need to use the C linker unless we're linking with LLVM which
     needs C++.
  2. Later when we start using C++ in Mono we will still want the C linker,
     because we will use a subset of C++ that doesn't depend on the C++ runtime
     library (because we don't want to break embedders that don't expect us to
     use C++).

So in either case which linker we use is a decision that we want to make
independent of what the file extensions look like.

So we set MONO_CXXLD in configure.  If LLVM is enabled, we use $CXX, otherwise
$CC.

Then in mono/mini/Makefile.am.in we set CCLD and CXXLD to MONO_CXXLD.  So
whatever automake decides we're going to use the linker that we want.

This partly reverts 988f4a2147 which tried
another approach (which turned out not to work).

This should also address https://github.com/mono/mono/issues/12060

Closes https://github.com/mono/mono/issues/12435

* [cxx] Fix link errors if both --enable-llvm and --enable-cxx are on
2019-01-28 16:22:00 -05:00
Ben Adams b4534a0cd2 string.EndsWith use SequenceEqual not SequenceCompareTo (#22207)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-28 09:38:26 +01:00
[email protected] 6c4199d25d Improve BinaryReader.ReadUInt32() perf by 30% when using MemoryStream (#22102)
BinaryReader.ReadInt32() has nice optimization which was missing from the ReadUInt32() version. Now both implementations are aligned.

ReadUInt32 and all the 64 bits types are now 30% to 50% faster than original implementation.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-28 09:38:26 +01:00
Ben Adams d35e06ff3c Shrink Task.Delay when used without cancellation (dotnet/coreclr#22233)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-28 09:38:26 +01:00
Dotnet-GitSync-Bot 3b2c1ca08a Mirror changes from mono/corefx,corert (#12645)
This PR contains mirrored changes from mono/corefx,corert


**Please REBASE this PR when merging**

 cc @jkotas
2019-01-28 09:33:53 +01:00
Marek Safar c40885324e Remove local Timer copy 2019-01-27 22:45:35 +01:00
Stephen Toub 6d13120e7c Remove several uses of VoidTaskResult (dotnet/coreclr#22238)
* Remove defunct netstandard code from ValueTask

* Remove several uses of VoidTaskResult

Currently TrySetResult/Canceled/Exception live on `Task<T>`.  There's no reason `TrySetCanceled` and `TrySetException` need to live there, as they only access state from the base `Task`, and so can be moved down.  `TrySetResult` needs the `TResult`, however in a variety of cases `Task<T>` is used with a `VoidTaskResult`, and for such cases we can just have a parameterless `TrySetResult()` on the base class as well, which can be used any time there is no `TResult` or when `default(TResult)` is the desired result.  This lets us switch several cases where we were using `Task<VoidTaskResult>` to just be `Task`, which saves 8 bytes on the task instance on 64-bit.  It also avoids an Interlocked.Exchange as part of the TrySetResult call.

This primarily affects Task.Delay and the non-generic variants of Task.WhenAll, ValueTask.AsTask(), Task.FromCanceled, and Task.FromException.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-27 22:45:35 +01:00
Filip Navara 0ed3a181c1 Move Timer to shared CoreLib partition. (dotnet/coreclr#22231)
* Move Timer to shared CoreLib partition.

* Move SignalNoCallbacksRunning back to shared code, add static EventWaitHandle.Set.

* Remove AppDomain references from shared Timer code, reshuffle some code out of SetTimer in non-shared code.

* Change m_ prefix to match code style.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-27 22:45:35 +01:00
Dotnet-GitSync-Bot f932a50d51 Mirror changes from mono/coreclr (#12635)
* Move Marshal::ZeroFree* to shared partition (dotnet/coreclr#22230)

* Move Marshal::ZeroFree* to shared partition

* Add managed version of SysStringByteLen

Signed-off-by: dotnet-bot <[email protected]>

* Remove duplicated code
2019-01-27 08:47:05 +01:00
Stephen Toub 6707bed13b Factor WinRT GetFolderPath into static accessible via reflection (#34873)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-26 14:40:18 +01:00
Dotnet-GitSync-Bot 87220f95fc Mirror changes from mono/coreclr (#12629)
* Move more Marshal methods to shared partition (dotnet/coreclr#22205)

* Move more Marshal methods to shared partition

* Implement ThrowExceptionForHR in managed

Signed-off-by: dotnet-bot <[email protected]>

* Remove local copy
2019-01-26 09:24:24 +01:00
monojenkins 39f669c465 [bcl] Update BCL Linked Size 2019-01-26 08:37:15 +01:00
Zoltan Varga ada3f474cc [aot] Print detailed stats only when --aot=stats is used. Avoid emitting 2 copies of preinited got slots in llvmonly mode. (#12614) 2019-01-25 18:52:36 -05:00
Ben Adams ed3649661e Skip rangecheck in string.EndsWith(char) (dotnet/coreclr#22206)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 20:32:21 +01:00
Ben Adams 32ae150897 Use AggressiveOptimization for intrinsics-based SpanHelpers (#22191)
* Use AggressiveOptimization for intrinsics-based SpanHelpers

* Remove from LastIndexOfAny

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 17:37:03 +01:00
Marek Safar 52dce5ed74 Reduce Task's static ctor dependencies (dotnet/coreclr#22172)
* Reduce Task's static ctor dependencies

* Remove defensive check

* Revert "Remove defensive check"

This reverts commit df15ab0350e8f44fc5cbb1a18c5211cd1de11989.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 17:31:31 +01:00
Larry Ewing e9a084b470 Merge pull request #12611 from marek-safar/linker-fixes
Add monolinker binary assets tests
2019-01-25 09:39:51 -06:00
Elliot Prior f5c045a546 Cancel CTS immediately if delay is zero. (dotnet/coreclr#18098)
The intended behaviour on specifying a delay of zero is that the CancellationTokenSource is cancelled immediately - before this change, it would depend on the scheduling of the timer callback which could lead to seeing a non-cancelled token. Now, it marks itself as cancelled immediately, without invoking any callbacks (as this method is called only from within the constructor of the object, before any callbacks could have been registered.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 15:19:59 +01:00
Ben Adams 7fb70b59cc Speedup .SequenceCompareTo(byte, ...) (dotnet/coreclr#22127)
* Speedup .SequenceCompareTo(byte, ...)

* Rename jump location

* Better annotations for clarity

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 14:06:39 +01:00
Katelyn Gadd acaa73b702 Integration and bug fixes to enable use of roslyn compiler server (#12476)
This PR still needs additional cleanup work to be ready to merge but it's getting close enough to be worth running tests and getting code review. The purpose of this PR is to make various bug fixes and infrastructure changes so that it is trivial to use the roslyn compiler server on a clean checkout.

Summary of the changes:
* configure.ac generates some additional variables in config.make that are used to configure the compiler server mode in make. You can then use the compiler server by passing ```ENABLE_COMPILER_SERVER=1``` to make or flipping the switch in config.make.
* config.make has two variables pointing to the compiler server version of roslyn. This lets you use a local build/checkout of roslyn but only when the compiler server is enabled. Once we update in-tree roslyn these vars can default to that. (The in-tree version of csc is not compatible with the compiler server.) The vars are named ```SERVER_CSC_LOCATION``` and ```VBCS_LOCATION```.
* config.make also has a variable that sets the name of the roslyn compiler server pipe. If you're trying to build multiple checkouts in parallel, or build in multiple user accounts, you'll need to use separate pipenames. You'll be able to set this from the command line once I tweak the config file with ```COMPILER_SERVER_PIPENAME=xxx```.
* basic_profile_check attempts to start the compiler server before any builds happen. I put it there because that was the only way I found to get it to always run before mcs builds. I spent a few hours trying to add a separate build target for this, and then gave up because makefiles. (I'd love to get suggestions on a better way to do this) Because it's nontrivial to track compiler server instances across builds, I just spawn a new one every time - this works fine because the compiler server has logic to detect an existing instance.
* I completely rewrote our implementation of Timer and its scheduler, because the existing one was burning an entire core at all times in the compiler server, mostly calling SortedList methods. The new implementation is probably not release-ready, but I focused on keeping it easy to audit and understand because attempts to preserve the existing logic kept breaking. Ideally we can just pull in corefx's timers here, but it looked non-trivial to do that.
* ReaderWriterLockSlim was checking Environment.ProcessorCount every time it was used, which in most configurations will result in a syscall to getpid() and another syscall to check our affinity. This was bottlenecking the compiler server really bad. I changed this to match most other threading code and use PlatformHelper.ProcessorCount instead.
* Our nunit.snk was corrupt (not sure how this happened) so I replaced it with the current nunit.snk from mainline nunit. Thanks to @jaredpar and other roslyn folks for troubleshooting this - it was causing problems for our msbuild infrastructure as well and I never figured that out.

Some work remains before the compiler server is good enough to use by default, which I will probably document here (or in tree? on a wiki?)
2019-01-25 14:05:29 +01:00
Zoltan Varga 124636c036 [jit] Add support for Unsafe intrinsics. (#12605) 2019-01-25 08:04:19 -05:00
Dotnet-GitSync-Bot f76994e0a1 Mirror changes from mono/coreclr,corert (#12612) 2019-01-25 14:01:09 +01:00
Tomasz Jaworski 901ca2bf6d Fix handling invalid Windows proxy config (#12595)
This fixes NullReferenceException that was thrown if:
-
 HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\ProxyEnable was set to true (1)
-
 HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\ProxyServer was set to null

Fixes #10030
2019-01-25 11:48:23 +01:00
Zoltan Varga f96d070114 [ci] Add CI_TAGS handling for ccache (#11305) 2019-01-25 11:37:18 +01:00
Zoltan Varga 9b8ff3260b [netcore] Port classes to netcore (#12548) 2019-01-25 09:47:31 +01:00
Marek Safar dcbe42a59c Add monolinker binary assets tests 2019-01-25 00:16:42 +01:00
Filip Navara 5f7db9082e Fix argument checks in ThreadPool.RegisterWaitForSingleObject. (#6887)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 00:07:11 +01:00
Marek Safar 06e109380e Fix the build 2019-01-25 00:00:06 +01:00
Tanner Gooding a184818adf Fixing some issues with the decimal parser/formatter (dotnet/coreclr#22070)
* Fixing the decimal formatting so that -0 prints as 0

* Fixing the decimal parser to consider digits still in the buffer as part of the zero/non-zero tail check

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 00:00:06 +01:00
Marek Safar ea13736f5c Move TaskContinuation to shared partition (dotnet/coreclr#22167)
* Move TaskContinuation to shared partition

* Remove TASK_STATE_THREAD_WAS_ABORTED from Task

* Use already existing ThrowAsync

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 00:00:06 +01:00
Michal Strehovský c313fc50ff Fix UWP VirtualAlloc import (dotnet/corert#6882)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-24 23:08:38 +01:00
Zoltan Varga af8d01c458 [runtime] Fix #ifdef NETCORE. 2019-01-24 23:07:56 +01:00
Alexander Kyte 56d8b8ec5f Merge pull request #12081 from alexanderkyte/posix_funcs_fix
[runtime] Guard usage of unix functions that aren't posix
2019-01-24 12:53:25 -05:00
Aleksey Kliger (λgeek) c90d1fe6d8 [image] Don't leak old image->name when closing (#12589) 2019-01-24 12:27:33 -05:00
Zoltan Varga afde007137 [wasm] Make the compilation of the empty.cs files quiet. (#12593)
[wasm] Make the compilation of the empty.cs files quiet.
2019-01-24 09:45:59 -05:00
Kenneth Pouncey f50cbd18ac [wasm] Fix AOT test build error message 'Unable to compile method'. (#12594)
* [wasm] Fix AOT test build error message 'Unable to compile method'.

* Remove `--aot-interp` command line option

* Remove a few more options

* add --linker option
2019-01-24 06:17:01 -05:00
Bernhard Urban c8552ac097 [runtime] cleanup around native crash info (#12581)
[runtime] cleanup around native crash info

Contributes to https://github.com/mono/mono/issues/12404
2019-01-24 06:05:44 -05:00
Bernhard Urban f394d7cd8e [spinlock] reduce interations in BCL test and extract it into a stress test
Reduces execution time from about two minutes down to five seconds for SpinLockTests.
2019-01-24 11:17:20 +01:00
Marek Safar 9f16ba6567 Fix the build 2019-01-24 11:15:35 +01:00
Ben Adams c68385b8a6 Speedup SpanHelpers.IndexOf{Any}(byte, ...) (dotnet/coreclr#22118)
* Speedup SpanHelpers.IndexOf(byte)

* 128 * 2 alignment

* Move TrailingZeroCountFallback to common SpanHelpers

So it can be used by other types than byte

* Speedup SpanHelpers.IndexOfAny(byte, ...)

* Indent for support flags

* More helpers, constency in local names/formatting, feedback

* Skip bounds check in software fallback

Signed-off-by: dotnet-bot <[email protected]>
2019-01-24 11:15:35 +01:00
Marek Safar 973b5c1b0f Move IOCompletionCallback to shared partition (dotnet/corert#6875)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-24 11:15:35 +01:00
Stephen Toub 677d83b4ab Implement IAsyncDisposable.ConfigureAwait (dotnet/coreclr#22160)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-24 10:56:26 +01:00
monojenkins 638c927fc1 [bcl] Update BCL Linked Size 2019-01-24 10:50:17 +01:00
Zoltan Varga 74fba1e6d3 [runtime] Avoid calling mono_pe_file_time_date_stamp () for images loaded from memory. (#12587) 2019-01-24 04:27:58 -05:00
Alexander Kyte 1a480b72d3 [runtime] Fix mono_pe_file_map logging (#12588) 2019-01-24 04:27:37 -05:00
Jérôme Laban a95bbcb8e7 Fix lookup for all SourceLink mappings, prefer local file over SourceLink 2019-01-23 21:09:44 -05:00
Zoltan Varga c821964b29 [runtime] Reorganize mono_dl_build_path () a bit, add a new case for netcore.
The netcore native libs are named System.Native.dylib etc. so they don't have the
lib prefix. Add a case for it.
2019-01-23 18:32:35 -05:00
Alexander Kyte 56d6010e59 [runtime] Fix wasm definition of HAVE_UTIME(S) 2019-01-23 18:30:23 -05:00
Marek Safar 76fcb3343d Fix the build 2019-01-24 00:09:19 +01:00
Filip Navara 9fe6dcb374 Move common ThreadPool code to shared CoreLib partition. (#22115)
* Move common ThreadPool code to shared CoreLib partition.

* Move numWorkingThreads counting out of shared code.

* Rename ThreadPoolGlobals.vmTpInitialized to threadPoolInitialized.
Remove exception handling from ThreadPoolWorkQueue.Dispatch.
Remove obsolete code from ThreadPoolWorkQueue.Dispatch.
Rename ThreadPool.EnsureVMInitialized to ThreadPool.EnsureInitialized.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-24 00:09:19 +01:00
Alexander Kyte 6843fff6a5 [runtime] Remove dependency on getpeername 2019-01-23 17:22:26 -05:00
Alexander Kyte a53c038871 [runtime] Add missing checks for HAVE_STRINGS_H 2019-01-23 17:22:26 -05:00
Alexander Kyte e49e6b55d0 [runtime] Remove missing check for HAVE_SYS_PARAM_H 2019-01-23 17:22:26 -05:00
Alexander Kyte 6d9af6db31 [runtime] Add missing checks for HAVE_SYS_RESOURCE_H 2019-01-23 17:22:26 -05:00
Alexander Kyte 79d3407c70 [runtime] Add missing checks for HAVE_NETINET_TCP_H 2019-01-23 17:22:26 -05:00
Alexander Kyte af3112213c [runtime] Remove dependency on atexit 2019-01-23 17:22:25 -05:00
Alexander Kyte 5c1585cfa9 [runtime] Remove dependency on openlog and closelog 2019-01-23 17:22:25 -05:00
Alexander Kyte 510aa8c702 [runtime] Make it easier to define DISABLE_SOCKETS 2019-01-23 17:22:25 -05:00
Alexander Kyte 9905044f66 [runtime] Remove dependency on utimes 2019-01-23 17:22:25 -05:00
Alexander Kyte a3f286c821 [runtime] Add missing HAVE_SYSCONF 2019-01-23 17:22:25 -05:00
Alexander Kyte 8ceec78af2 [runtime] Remove dependency on GetHostName 2019-01-23 17:22:25 -05:00
Alexander Kyte d185d31120 [runtime] Remove dependency on msync 2019-01-23 17:22:25 -05:00
Alexander Kyte 498a57aa9c [runtime] Remove dependency on getdtablesize 2019-01-23 17:22:25 -05:00
Alexander Kyte cd375339e6 [runtime] Remove dependency on lstat 2019-01-23 17:22:25 -05:00
Alexander Kyte 3a5199388d [runtime] Remove build dependency on chmod 2019-01-23 17:22:25 -05:00
Alexander Kyte af0f33f81a [runtime] Remove dependency on makedev 2019-01-23 17:22:24 -05:00
Alexander Kyte 68ad522689 [runtime] Remove dependency on readlink 2019-01-23 17:22:24 -05:00
Martin Baulig e060c5b0f0 [eglib]: Fix memory leak in g_find_program_in_path(). #11615. (#12580) 2019-01-23 16:41:46 -05:00
Alexander Kyte a80d44980c Merge pull request #12082 from alexanderkyte/no_direct_errno
[runtime] Create some indirection for errno setting
2019-01-23 16:28:09 -05:00
Larry Ewing 63cbf6126e Merge pull request #12551 from kjpou1/wasm-aot-link
[wasm] AOT linkage and samples
2019-01-23 15:25:42 -06:00
Jan Kotas 63d2f0e6ec Fix CoreRT build after moving Task.cs to shared partition
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:16:07 +01:00
Filip Navara 25ce6d849d Fix possibly unintentional use of bit-wise or operator. (#22152)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:16:07 +01:00
alexk000 3fd3eb5081 Remove variable name duplication (dotnet/coreclr#22155)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:16:07 +01:00
Marek Safar 89940bd801 Remove redundant files 2019-01-23 22:06:53 +01:00
Marek Safar 39b9e2099f Move Task to shared partition (dotnet/coreclr#22105)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:06:53 +01:00
Ben Adams 5bb7ab2f7d Remove duplicate requiresSynchronization params attribute (#22143)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:06:53 +01:00
Filip Navara d22d97718a Update parameter names in PInvoke signatures to match MSDN documentation.
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:06:53 +01:00
Filip Navara ee6597030e Build fixes.
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:06:53 +01:00
Jérôme Laban 133088a437 Update GetScriptSource more async, show exception message. 2019-01-23 15:50:55 -05:00
Zoltan Varga 80bc0069e4 [llvmonly] Move the mono_aot_init_llvm_method family of functions to llvmonly-runtime.c, rename them to mini_llvmonly_init_... for consistency. (#12575)
[llvmonly] Move the mono_aot_init_llvm_method family of functions to llvmonly-runtime.c, rename them to mini_llvmonly_init_... for consistency.
2019-01-23 12:25:53 -05:00
Larry Ewing 8ac757202a Merge pull request #12254 from marek-safar/bcl-fixes
Enables SRE for wasm
2019-01-23 10:24:39 -06:00
Kenneth Pouncey 45ccb2b185 Address review comments 2019-01-23 17:03:50 +01:00
Kenneth Pouncey b6d5809aa2 Update packager to address review comments
- Add `verbose` CL flag to control `--verbose` mode sent to `monolinker` during link phase.

```
  --verbose (set verbose option on link)
        type: bool  default: false
```
2019-01-23 16:21:04 +01:00
Kenneth Pouncey ab95e60634 Remove netstandard from list of core assemblies as it is now implemented in monolinker. 2019-01-23 15:21:53 +01:00
Sebastien Pouliot d9508b8086 [System.Net.Http] Fix CFNetworkHandler when no data is sent
The handler receive an `Open` and the a `Close` event but never a
`DataAvailable` event.

So it _hangs_ if only a `200` status is received (since the headers
are not considered _data_) received from the web server.

This is because some initialization only occurs inside
`HandleHasBytesAvailableEvent` which is now called, on `Close`,
to ensure the initialization is done before completing the request.

This, along with a cancellation check, makes the test case from
https://github.com/xamarin/xamarin-macios/issues/5190 work properly
with this handler.

Fixes https://github.com/xamarin/xamarin-macios/issues/5289
2019-01-23 14:36:20 +01:00
Bijan Tabatabai 7c87bd7c19 [Fix] GetActiveTcpConnections now returns correct state in unix
The values of the enum for the TcpState are different in Unix systems
than in .NET, so a function was added to convert between the two.

Signed-off-by: Bijan Tabatabai <[email protected]>
2019-01-23 14:34:14 +01:00
Maxim Lipnin b56f4d9184 Japanese calendar era change (#12556)
* Support new Japanese calendar eras

* Port Formatting Japanese First Year of Era

* Fix formatting

* Update switches for mobile mode

* Bump corefx
2019-01-23 14:33:00 +01:00
Martin Baulig 22d01c707c [Mono.Security]: Remove some obsolete test tools.
These tools were using the obsolete `Mono.Security.Protocol.Tls` code
(Legacy TLS), which is scheduled for removal.
2019-01-23 14:32:16 +01:00
Kenneth Pouncey 96f2de301a Merge branch 'master' of https://github.com/mono/mono into wasm-aot-link 2019-01-23 14:29:41 +01:00
Kenneth Pouncey 2aeb4afa26 Bump linker (#12560)
* Bump linker

* Bump linker
2019-01-23 08:27:43 -05:00
monojenkins 98c4e0efd7 [csproj] Update project files 2019-01-23 12:55:42 +00:00
Martin Baulig 5c71a7872d [SslStream]: Flatten exceptions in sync SslStream APIs.
The sync APIs `SslStream.AuthenticateAsClient()` and `AuthenticateAsServer()`
should not throw `AggregateException`.

Fixes #9418.
2019-01-23 13:13:25 +01:00
Steve Pfister 26e0b1deec Fixes #12479 - Fixed issue where time lookups on a symlink (GetLastWrite, Creation, … (#12533)
When given a path to a symlink `GetLastWriteTime` returned the time for the actual file.  This PR resolves that.

Fixes https://github.com/mono/mono/issues/12479
2019-01-23 13:05:59 +01:00
Kenneth Pouncey 4a29e830b3 Merge branch 'master' of https://github.com/mono/mono into wasm-aot-link 2019-01-23 11:44:33 +01:00
Marek Safar dc9bc9e0e6 Enables SRE for wasm 2019-01-23 11:17:47 +01:00
Zoltan Varga 8c7ef3c7a3 [jit] Enable generic sharing for empty structures. (#12570)
[jit] Enable generic sharing for empty structures.
2019-01-23 04:35:52 -05:00
Larry Ewing bd063d89ad Merge pull request #12566 from vargaz/dir-dependency
[bcl] Fix the dependencies for the corlib tests.
2019-01-22 19:44:06 -06:00
Larry Ewing d7be84abc4 Merge pull request #12554 from BrzVlad/feature-interp-virtperf
[interp] Improve performance of virtual calls
2019-01-22 18:43:55 -06:00
Vlad Brezae 5b2d3972a0 [utils] Fix potential overflow (#12559)
[utils] Fix potential overflow

When doing array copy of 16+ GB.
2019-01-22 18:45:27 -05:00
Zoltan Varga d41e8dd5eb [bcl] Fix the dependencies for the corlib tests. 2019-01-22 12:44:36 -05:00
Alexander Kyte 7f1619b570 [runtime] Create some indirection for errno setting 2019-01-22 11:51:12 -05:00
Vlad Brezae ad7cb105ec [sgen] Don't trigger concurrent collections if we exceed soft heap limit (#12536)
Concurrent gc (mark / sweep) allows the heap to grow further, which is not what we want if we already exceeded the limit.
2019-01-22 11:13:38 -05:00
Alexander Kyte 6bcd623e7c Merge pull request #12518 from alexanderkyte/merp_thread_hash
[crash] Place hashes into the json file for all threads
2019-01-22 11:07:59 -05:00
Vlad Brezae 7cdde25858 [interp] Fall back to old implementation when calling on proxy
Virtual call optimizations don't handle remoting yet
2019-01-22 16:56:21 +02:00
Vlad Brezae 81330cd5ac [interp] Allocate interface table as part of MonoVTable 2019-01-22 16:56:21 +02:00
Vlad Brezae 42cc325b44 [interp] Use fast virtual invoke code also for interfaces
As with virtual generic calls, when doing an interface call, we need to iterate over all the methods in the hashing slot.
2019-01-22 16:55:46 +02:00
Vlad Brezae 11aca2f939 [interp] Improve performance of generic virtual calls
Different instantiations of generic virtual methods occupy the same slot in the vtable. We probe them using a single linked list, by the same logic of jit's imt trampolines.
2019-01-22 16:55:46 +02:00
Vlad Brezae 2c73aa015b [interp] Improve performance of virtual calls
We allocate a new interp vtable array that we store inside the type's vtable. This array has the same logic as the jit vtable array and it stores InterpMethod pointers. We embed the virtual method slot in the interp instruction stream.
2019-01-22 16:55:46 +02:00
Aleksey Kliger 55d29aa7d4 [netcore] Make Assembly.Load (new AssemblyName (corlib_name + ".dll")) work again
Partly revert a change in https://github.com/mono/mono/pull/12478

CoreCLR treats `Assembly.Load (new AssemblyName ("System.Private.CoreLib.dll"))`
the same as `Assembly.Load (new AssemblyName ("System.Private.CoreLib"))`  (and
.NET Framework behaves likewise with "mscorlib.dll").
2019-01-22 15:43:11 +01:00
Alexander Kyte 470354fa81 [crash] Test and fix stability of native crash pipeline(s) (#12125)
* [runtime] Make infrastructure for merp tests

* [runtime] Fix dumping when crash happens without sigctx

* [runtime] Disable crashy (886/1000 runs) stacktrace walker

* [crash] Remove usage of allocating build/os info functions

* [crash] Remove often-crashing g_free on native crash path

* [crash] Add crash_reporter checked build

We add a checked build mode that asserts when mono mallocs inside of
the crash reporter. It makes risky allocations into assertions. It's
useful for automated testing because the double-abort often represents
itself as an indefinite hang. If it happens before the thread dumping
supervisor process is started, or after it ends, the crash reporter
hangs.

* [crash] Remove reliance on nested SIGABRT/double-fault (broken on OSX)

* [crash] Fix top-level handling of double faults/assertions

* [runtime] Make fatal unwinding errors return into handled error paths

* [crash] Change dumper logging for better info

* [runtime] Fix handling of segfault on sgen thread

Threads without domains that get segfaults will end up in
this handler. It's not safe to call this function with a NULL domain.

See crash below:

```
* thread #1, name = 'tid_307', queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=2, address=0x10eff40f8)
  * frame #0: 0x000000010e1510d9 mono-sgen`mono_threads_summarize_execute(ctx=0x0000000000000000, out=0x0000001000000000, hashes=0x0000100000100000, silent=4096, mem="", provided_size=2199023296512) at threads.c:6414
    frame #1: 0x000000010e152092 mono-sgen`mono_threads_summarize(ctx=0x000000010effda00, out=0x000000010effdba0, hashes=0x000000010effdb90, silent=0, signal_handler_controller=1, mem=0x0000000000000000, provided_size=0) at threads.c:6508
    frame #2: 0x000000010df7c69f mono-sgen`dump_native_stacktrace(signal="SIGSEGV", ctx=0x000000010effef48) at mini-posix.c:1026
    frame #3: 0x000000010df7c37f mono-sgen`mono_dump_native_crash_info(signal="SIGSEGV", ctx=0x000000010effef48, info=0x000000010effeee0) at mini-posix.c:1147
    frame #4: 0x000000010de720a9 mono-sgen`mono_handle_native_crash(signal="SIGSEGV", ctx=0x000000010effef48, info=0x000000010effeee0) at mini-exceptions.c:3227
    frame #5: 0x000000010dd6ac0d mono-sgen`mono_sigsegv_signal_handler_debug(_dummy=11, _info=0x000000010effeee0, context=0x000000010effef48, debug_fault_addr=0xffffffffffffffff) at mini-runtime.c:3574
    frame #6: 0x000000010dd6a8d3 mono-sgen`mono_sigsegv_signal_handler(_dummy=11, _info=0x000000010effeee0, context=0x000000010effef48) at mini-runtime.c:3612
    frame #7: 0x00007fff73dbdf5a libsystem_platform.dylib`_sigtramp + 26
    frame #8: 0x0000000110bb81c1
    frame #9: 0x000000011085ffe1
    frame #10: 0x000000010dd6d4f3 mono-sgen`mono_jit_runtime_invoke(method=0x00007faae4f01fe8, obj=0x0000000000000000, params=0x00007ffee1eaa180, exc=0x00007ffee1ea9f08, error=0x00007ffee1eaa250) at mini-runtime.c:3215
    frame #11: 0x000000010e11509d mono-sgen`do_runtime_invoke(method=0x00007faae4f01fe8, obj=0x0000000000000000, params=0x00007ffee1eaa180, exc=0x0000000000000000, error=0x00007ffee1eaa250) at object.c:2977
    frame #12: 0x000000010e10d961 mono-sgen`mono_runtime_invoke_checked(method=0x00007faae4f01fe8, obj=0x0000000000000000, params=0x00007ffee1eaa180, error=0x00007ffee1eaa250) at object.c:3145
    frame #13: 0x000000010e11aa58 mono-sgen`do_exec_main_checked(method=0x00007faae4f01fe8, args=0x000000010f0003e8, error=0x00007ffee1eaa250) at object.c:5042
    frame #14: 0x000000010e118803 mono-sgen`mono_runtime_exec_main_checked(method=0x00007faae4f01fe8, args=0x000000010f0003e8, error=0x00007ffee1eaa250) at object.c:5138
    frame #15: 0x000000010e118856 mono-sgen`mono_runtime_run_main_checked(method=0x00007faae4f01fe8, argc=2, argv=0x00007ffee1eaa760, error=0x00007ffee1eaa250) at object.c:4599
    frame #16: 0x000000010de1db2f mono-sgen`mono_jit_exec_internal(domain=0x00007faae4f00860, assembly=0x00007faae4c02ab0, argc=2, argv=0x00007ffee1eaa760) at driver.c:1298
    frame #17: 0x000000010de1d95d mono-sgen`mono_jit_exec(domain=0x00007faae4f00860, assembly=0x00007faae4c02ab0, argc=2, argv=0x00007ffee1eaa760) at driver.c:1257
    frame #18: 0x000000010de2257f mono-sgen`main_thread_handler(user_data=0x00007ffee1eaa6a0) at driver.c:1375
    frame #19: 0x000000010de20852 mono-sgen`mono_main(argc=3, argv=0x00007ffee1eaa758) at driver.c:2551
    frame #20: 0x000000010dd56d7e mono-sgen`mono_main_with_options(argc=3, argv=0x00007ffee1eaa758) at main.c:50
    frame #21: 0x000000010dd5638d mono-sgen`main(argc=3, argv=0x00007ffee1eaa758) at main.c:406
    frame #22: 0x00007fff73aaf015 libdyld.dylib`start + 1
    frame #23: 0x00007fff73aaf015 libdyld.dylib`start + 1
  thread #2, name = 'SGen worker'
    frame #0: 0x000000010e2afd77 mono-sgen`mono_get_hazardous_pointer(pp=0x0000000000000178, hp=0x000000010ef87618, hazard_index=0) at hazard-pointer.c:208
    frame #1: 0x000000010e0b28e1 mono-sgen`mono_jit_info_table_find_internal(domain=0x0000000000000000, addr=0x00007fff73bffa16, try_aot=1, allow_trampolines=1) at jit-info.c:304
    frame #2: 0x000000010dd6aa5f mono-sgen`mono_sigsegv_signal_handler_debug(_dummy=11, _info=0x000070000fb81c58, context=0x000070000fb81cc0, debug_fault_addr=0x000000010e28fb20) at mini-runtime.c:3540
    frame #3: 0x000000010dd6a8d3 mono-sgen`mono_sigsegv_signal_handler(_dummy=11, _info=0x000070000fb81c58, context=0x000070000fb81cc0) at mini-runtime.c:3612
    frame #4: 0x00007fff73dbdf5a libsystem_platform.dylib`_sigtramp + 26
    frame #5: 0x00007fff73bffa17 libsystem_kernel.dylib`__psynch_cvwait + 11
    frame #6: 0x00007fff73dc8589 libsystem_pthread.dylib`_pthread_cond_wait + 732
    frame #7: 0x000000010e28d76d mono-sgen`mono_os_cond_wait(cond=0x000000010e44c9d8, mutex=0x000000010e44c998) at mono-os-mutex.h:168
    frame #8: 0x000000010e28df4f mono-sgen`get_work(worker_index=0, work_context=0x000070000fb81ee0, do_idle=0x000070000fb81ed4, job=0x000070000fb81ec8) at sgen-thread-pool.c:165
    frame #9: 0x000000010e28d2cb mono-sgen`thread_func(data=0x0000000000000000) at sgen-thread-pool.c:196
    frame #10: 0x00007fff73dc7661 libsystem_pthread.dylib`_pthread_body + 340
    frame #11: 0x00007fff73dc750d libsystem_pthread.dylib`_pthread_start + 377
    frame #12: 0x00007fff73dc6bf9 libsystem_pthread.dylib`thread_start + 13
  thread #3, name = 'Finalizer'
    frame #0: 0x00007fff73bf6246 libsystem_kernel.dylib`semaphore_wait_trap + 10
    frame #1: 0x000000010e1d9c0a mono-sgen`mono_os_sem_wait(sem=0x000000010e43e400, flags=MONO_SEM_FLAGS_ALERTABLE) at mono-os-semaphore.h:84
    frame #2: 0x000000010e1d832d mono-sgen`mono_coop_sem_wait(sem=0x000000010e43e400, flags=MONO_SEM_FLAGS_ALERTABLE) at mono-coop-semaphore.h:41
    frame #3: 0x000000010e1da787 mono-sgen`finalizer_thread(unused=0x0000000000000000) at gc.c:920
    frame #4: 0x000000010e152919 mono-sgen`start_wrapper_internal(start_info=0x0000000000000000, stack_ptr=0x000070000fd85000) at threads.c:1178
    frame #5: 0x000000010e1525b6 mono-sgen`start_wrapper(data=0x00007faae4f31bd0) at threads.c:1238
    frame #6: 0x00007fff73dc7661 libsystem_pthread.dylib`_pthread_body + 340
    frame #7: 0x00007fff73dc750d libsystem_pthread.dylib`_pthread_start + 377
    frame #8: 0x00007fff73dc6bf9 libsystem_pthread.dylib`thread_start + 13
  thread #4
    frame #0: 0x00007fff73c0028a libsystem_kernel.dylib`__workq_kernreturn + 10
    frame #1: 0x00007fff73dc7009 libsystem_pthread.dylib`_pthread_wqthread + 1035
    frame #2: 0x00007fff73dc6be9 libsystem_pthread.dylib`start_wqthread + 13
(lldb)
```

* [crash] Add signal-safe mmap/file "allocator"

* [crash] Remove use of static memory from dumper

* [runtime] Reduce print buffer size for lockless printer.

Each frame that prints ends up increased by the size of buff.
In practice, clang often fails to deduplicate some of these buffers,
leading to 30k-big stackframes.

It was noticed by a series of hard-to-diagnose segfaults on stacks that
looked otherwise fine during the crash reporting stress test.

This change fixes this, making stacks a 1/10th of the size. It doesn't
seem to break the crash reporter messages anywhere (may need to shrink
other "max name length" fields), and it's not mission-critical anywhere
else.

* [crash] Use async-safe file memory for dumper internals

* [crash] Add memory barriers around merp configuration

* [crash] Use signal-safe printers on all native crash paths

* [crash] Move gdb/lldb lookup to startup

* [runtime] Move MOSTLY_ASYNC_SAFE_FPRINTF to eglib

* [runtime] Fix all callsites of MOSTLY_ASYNC_SAFE_PRINTF

* [runtime] Fix all callsites of MOSTLY_ASYNC_SAFE_FPRINTF

* [crash] Switch to signal-safe exit function

* [crash] Make dumper enum in managed

* [runtime] Add more information to managed frame

* [crash] Make async_safe printers inlined

* [runtime] Move basic pe_file functionality into proclib

* [crash] Fix handling of thread attributes
2019-01-22 09:09:22 -05:00
Alexander Kyte f4d059f903 [runtime] Remove two missing tests from monodroid+aot excludes 2019-01-22 14:08:03 +01:00
Marek Safar e1d3838af6 Fix the build 2019-01-22 13:40:28 +01:00
Filip Navara dd90410129 Move MemoryFailPoint to shared CoreLib partition (dotnet/coreclr#22104)
* Move MemoryFailPoint to shared CoreLib partition.

* Split MemoryFailPoint into Unix and Windows versions.

* Replace MemoryFailPoint.GetMemorySettings FCall with GC.GetSegmentSize to make sharing with CoreRT easier.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-22 13:40:28 +01:00
Zoltan Varga 4e3264f975 [runtime] Move some internal methods and icalls from MethodBase to RuntimeMethodInfo to ease netcore integration. 2019-01-22 13:30:09 +01:00
Jan Kotas b4012bae49 Fix CoreRT build breaks
Signed-off-by: dotnet-bot <[email protected]>
2019-01-22 12:22:10 +01:00
Marek Safar a61fe27946 Fix the build 2019-01-22 10:14:37 +01:00
Marek Safar 5f59e8f9a3 Move TplEtwProvider to shared partition (dotnet/coreclr#22120)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-22 10:14:37 +01:00
Kenneth Pouncey ef5e58587e Remove link-mode=None
- Address reviewer comments
2019-01-22 10:08:21 +01:00
Martin Baulig a7cfa881fb [System]: Fix race condition in SystemDependencyProvider.Initialize(). #12538. (#12541) 2019-01-22 09:14:56 +01:00
Kenneth Pouncey 402859587e Update README.md 2019-01-22 07:45:58 +01:00
Kenneth Pouncey bc39d7fcd9 Update README.md 2019-01-22 07:42:14 +01:00
Kenneth Pouncey 434d70053d Update README.md
Fix link
2019-01-22 07:39:46 +01:00
Kenneth Pouncey 9d82a07db3 [wasm] Update documentation 2019-01-22 07:21:19 +01:00
Kenneth Pouncey 4173fb24f2 [wasm] Modify packager linkage for AOT'd code.
- Add new experimental command line option

   - --link-mode=None|SdkOnly|Full        Set the link type used for AOT. (EXPERIMENTAL)
   - `None` no linking.
   - `SdkOnly` only link the Core libraries.
   - `Full` link Core and User assemblies. **(default)**

- Add the Facades directory to the resolve paths.
- Treat netstandard, WebAssembly.Bindings and WebAssembly.Net.Http as core libraries.  `monolinker.exe` does not see `netstandard` as a core library.
2019-01-22 07:20:45 +01:00
Kenneth Pouncey d2635afea2 [wasm] Fix a few issues that crop up from time to time. Mostly affects running in an AOT'd application. 2019-01-22 06:36:27 +01:00
Kenneth Pouncey 045eed6107 [wasm] Fix a problem with void methods that are invoked.
- The problem stems from void methods returning a corrupted MonoObject when the method that is invoked is marked as `void`.
- Internally the cwrap'd invoke method is defined as returning a `number` which internally will return the result from `mono_wasm_invoke_method` of the driver.  In the case of `void` methods this may contain invalid address reference causing a memory access crash if referenced.
2019-01-22 06:35:11 +01:00
Kenneth Pouncey 5cfcd27534 [wasm] Add two new AOT'd samples targets 2019-01-22 06:25:55 +01:00
Jérôme Laban 920074b55f Fix invalid csharp_space_between_method_declaration_name_and_open_parenthesis 2019-01-21 17:52:12 -05:00
Jérôme Laban 90234bd386 Reformat additions based on editor config file 2019-01-21 17:47:55 -05:00
Jérôme Laban bba2b18202 Adjust editor config based on https://www.mono-project.com/community/contributing/coding-guidelines/#style-guidelines 2019-01-21 17:47:09 -05:00
Martin Baulig 13540da80b [System]: Correctly dispose inner stream in WebResponseStream. #11928. (#12459) 2019-01-21 23:24:57 +01:00
Stephen Toub bce478353a Avoid intermediate strings in some StringBuilder formatting (#22111)
* Avoid intermediate strings in some StringBuilder formatting

Several appends to string builders are first creating strings and then appending those strings, and they're not using the existing Append(primitive) overloads because they want to customize the format string or provider as part of appending the value.  This fixes a few of those cases, using another internal AppendSpanFormattable overload on StringBuilder.

* Address PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-01-21 22:36:43 +01:00
Bernhard Urban aa0f15fdca [tvOS] cleanup defines for tvOS (#12539)
Fixes https://github.com/mono/mono/issues/11697
2019-01-21 21:36:06 +01:00
Alexis Christoforides cbfd736864 [configure] Small fix in sigaltstack() checking on cross-compiler case (#12365) 2019-01-21 21:35:49 +01:00
Thays Grazia 5078e23d75 [Debugger] Checking server version before call elapsed_time (#12511)
* The version of the server and client should be bumped to call the elapsed_time.

* Removing extra {

* Calling correctly.

* This should be checked in ThreadMirror.ElapsedTime instead using vm.CheckProtocolVersion (), so calling the public method will fail.
2019-01-21 15:28:12 -05:00
Jérôme Laban 4461e1e6a1 Adjust formatting, add .editorconfig 2019-01-21 12:50:50 -05:00
Jérôme Laban 78ef51b90a Add support for full document path
- Show the full file name in chrome source browser
- Fix support for duplicate file names in different paths
2019-01-21 11:26:12 -05:00
Jérôme Laban 4d4dc12932 Fix "Collection was modified" for pending operations 2019-01-21 11:26:12 -05:00
Jérôme Laban 91909b2b24 Fix NRE for unknown method token for some generated methods 2019-01-21 11:26:12 -05:00
Jérôme Laban 6160337c0f Fixed support for local urls 2019-01-21 11:26:12 -05:00
Jérôme Laban 49fddf283f Add support for mono pdbs, sourcelink 2019-01-21 11:26:12 -05:00
Marek Safar 6fee0c0ad8 [build] Fix netcore build (#12526)
* [build] Fix netcore build

* Fix Mono env parsing for netcore and reduce Task dependencies

* Fix the build
2019-01-21 16:26:51 +01:00
Zoltan Varga 86bae56326 [runtime] Make -Wreturn-type into an error. (#9915) 2019-01-21 08:57:57 -05:00
Zoltan Varga 32e5af52d9 [wasm] Add a --il-strip option to strip IL code from assemblies in AOT mode. (#12529) 2019-01-21 08:41:12 -05:00
Romain Marcadier-Muller 7cd9e0314d [signcode.exe] Allow use of new hash algorithm (#11999)
Enable SHA256, SHA384 and SHA512 hash algorithms to be used for
Authenticode signatures. This enables producing digital signatures that
are trustworthy using the `mono` tooling.

Fixes #7517
2019-01-21 08:29:45 -05:00
Jay Krell 32aa0ad724 [configure] Silently automatically disable Boehm on x86_64-mingw. (#12274) 2019-01-21 08:28:38 -05:00
Zoltan Varga 78be74cc6b [llvmonly] Mixed mode fixes (#12521)
* [llvmonly] Fix dynamic delegate creation in mixed mode.

* [llvmonly] Fix support for virtual calls in mixed mode. Handle calls which end up being not virtual, and add wrappers
for virtual call signatures too.

* [llvmonly] Disable calling aot-ed synchronized methods from the interpreter, it hits an assert in mono_jit_compile_method_jit_only ().
2019-01-21 07:44:47 -05:00
Kenneth Pouncey 18bd1f434d Add hello.exe build target to make file so aot-sample runs. (#12534) 2019-01-21 13:33:54 +01:00
Zoltan Varga 7318005f0c [wasm] Distribute wasm_tools. (#12532) 2019-01-21 07:28:08 -05:00
Marek Safar 65b441964e Move Task factory type to shared partition (dotnet/coreclr#22089)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-21 12:08:53 +01:00
Bernhard Urban 8730101b3c [ios] enable llvm for watch64_32 runtime (#12497)
I lost that change during upstreaming 🙁
2019-01-21 11:12:02 +01:00
Zoltan Varga 99944c65c5 [wasm] Add support for linking out unused icalls in interpreter and aot+interp mode using a new --link-icalls option. (#12512)
* [wasm] Add a 'wasm-tuner' helper tool which is ran during the app build process.
Currently it only supports one option: --gen-icall-table which generates a linked
icall table based on a linked mscorlib.dll.

* [wasm] Add support for linking out unused icalls in interpreter and aot+interp mode using a new --link-icalls option.

This involves the following steps:
- mono --print-icall-table > icall-table.json
- tuner.exe --gen-icall-table icall-table.json linker-out/mscorlib.dll > icall-table.h
- link icall-table.h into the final executable.

The downside is that this requires compiling a new mono.wasm even in interpreter mode.

* Update README.

* Fix thisdir.

* [csproj] Update project files
2019-01-20 22:34:14 -05:00
Ben Adams 82b940f0e0 Use List<T>.ToArray() in places (dotnet/coreclr#22101)
* Use ReadOnlySpan.ToArray in places

* Use List.ToArray

* Don't take .Length in to local and use as loop condition

Signed-off-by: dotnet-bot <[email protected]>
2019-01-21 01:13:34 +01:00
Jan Kotas 4833a124da Cleanup array related FCalls (dotnet/coreclr#22097)
* Cleanup Array FCalls

* Disable outdated CoreFX tests

https://github.com/dotnet/corefx/pull/34700

Signed-off-by: dotnet-bot <[email protected]>
2019-01-20 17:37:51 +01:00
Jan Kotas 698e3cb786 Fix CoreCLR build for changes in shared partition
Signed-off-by: dotnet-bot <[email protected]>
2019-01-20 09:24:44 +01:00
Jan Kotas 3505ee705e Fix build for ProjectN/WinRTInterop Delete superfluous AsyncCausalityTracer arguments
Signed-off-by: dotnet-bot <[email protected]>
2019-01-19 20:39:48 +01:00
Marek Safar 091f7c3fc8 Fix build
Signed-off-by: dotnet-bot <[email protected]>
2019-01-19 20:39:48 +01:00
Miguel de Icaza 917d219d54 [jit] Constant folding for some Math operations on doubles (#9281)
[jit] Constant folding for some Math operations on doubles

This adds support for constant folding of additions and
multiplications of doubles as well as constant folding of Math.Sin,
Math.Cos, Math.Abs and Math.Sqrt.

Inspired by some changes that went into RyuJit:

https://github.com/AndreyAkinshin/aakinshin.net/blob/master/web/_posts/en/2015/ryujit-rc-and-constant-folding.md
2019-01-19 04:45:39 -05:00
Aleksey Kliger 1a965367e5 [netcore] Add an assembly preload hook by parsing TRUSTED_PLATFORM_ASSEMBLIES property 2019-01-19 09:14:44 +01:00
Aleksey Kliger 2037ad6d09 [assembly] for ENABLE_NETCORE load System.Private.CoreLib from preload hook
in mono_assembly_load_corlib, load "System.Private.CoreLib" using the preload
hook, don't bother with the mono assemblies paths
2019-01-19 09:14:44 +01:00
Aleksey Kliger 8c02942689 [netcore] Don't set up mono_defaults.mono_method_message_class
We don't have a MonoMethodMessage in System.Private.CoreLib yet.  Not sure if we need it.
2019-01-19 09:14:44 +01:00
Aleksey Kliger (λgeek) 7f75e05522 [netcore] Small runtime changes (#12503)
* [configure] --with-core should disable remoting, sre.save and appdomains

* [class-init] with ENABLE_NETCORE System.Array has some constant fields

* [object] for NETCORE don't handle appdomain unload exception specially

Since it doesn't exist in System.Private.CoreLib.dll (it's no netstandard.dll)
2019-01-18 23:34:02 +01:00
Aleksey Kliger (λgeek) 58cb6aa49c [netcore] System.Private.CoreLib changes to match runtime expectations. (#12504)
1. Add classes that the runtime depends on:
   * System.Reflection.RuntimeAssembly and System.Reflection.MonoAssembly
   * System.Mono.MonoDomain and System.Mono.MonoDomainSetup
2. Add fields to some classes so they match what `object-internals.h` expect on the native side.
3. Make a non-`abstract` `System.RuntimeType` stub.
   `System.Type` and `System.RuntimeType` need to have fields that match `object-internals.h` and also the runtime wants to create instances of this type and things go wrong if it's abstract.
2019-01-18 23:33:24 +01:00
Alexander Kyte 34cc1abd19 [crash] Place hashes into the json file for all threads 2019-01-18 17:30:28 -05:00
Alexander Kyte 6e80adbe43 [runtime] Don't try (slow) dlopen on android if it doesn't exist (#12074)
On android, the dlopen call will take around 1ms per AOT module we try to load. By not using dlopen with the existence check, we rely on a much slower dlopen check that happens later. I think they support dlopen of non-resolved names.

This might break a few things if we don't use the full path to dlopen. If it does, we should probably add existence checks at the caller, but this will be an optimization that works everywhere.
2019-01-18 22:45:56 +01:00
Alexander Köplinger ee8e8288a6 [System] Fix test compilation on Android 2019-01-18 22:35:25 +01:00
Marek Safar 076b36d662 Merge pull request #12505 from Dotnet-GitSync-Bot/mirror-merge-10019180
Mirror changes from mono/coreclr
2019-01-18 20:19:04 +01:00
Marek Safar 56848baf6a Fix the build 2019-01-18 20:16:04 +01:00
Alexander Kyte c375ef7370 Merge pull request #12053 from alexanderkyte/fixup_aot_probe
[runtime] Add opt-out for AOT file probing with MONO_AOT_MODE_NONE
2019-01-18 13:28:45 -05:00
Marek Safar 2963d731c3 Move AsyncCausality to shared partition (dotnet/coreclr#22062)
* Move AsyncCausality to shared partition

* Set FeatureAsyncCausalityTracer property

Signed-off-by: dotnet-bot <[email protected]>
2019-01-18 18:20:29 +00:00
Aleksey Kliger 278858fe62 [class-init] Allow ghc_slot or finalize_slot == 0
Uninitialized slot values are -1, not 0.

For example GetHashCode could be in slot 0.
2019-01-18 12:26:58 -05:00
Marek Safar 0a86bd4bf7 Fixes build 2019-01-18 16:10:00 +01:00
Stephen Toub 2cd281fae5 Move Environment to shared CoreLib (dotnet/corefx#34654)
Rather than having Environment partially live in corefx and call into an EnvironmentAugments type in CoreLib that in turn calls into an Environment type in CoreLib, we're just moving Environment to live in CoreLib.

To start that, this PR moves Environment and its dependencies from their current locations into the shared CoreLib.  Those changes will mirror over to coreclr.  After that, I'll fix it up to work in CoreLib. And once those changes are built and available back to corefx, I'll update System.Runtime.Extensions to just use the functionality from CoreLib and delete remaining unnecessary code from corefx.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-18 16:10:00 +01:00
Michal Strehovský 3c0c8adbf8 Enable detection of HW intrinsics (dotnet/corert#6836)
I took the liberty of marking the types containing the hardware intrinsics as [Intrinsic] to avoid doing a name check on everything in the system module. It feels like we should take advantage of this attribute in CoreCLR too.

This doesn't actually enable the support because RyuJIT unconditionally disables HW intrinsics for prejit (both CoreRT and CPAOT are considered prejit). We might want to do something about this on the RyuJIT side to address that (for CPAOT, to be able to pregenerate best code possible ahead of time, assuming a fixed ISA; and for CoreRT without JIT, where the concerns about AVX-SSE penalty don't apply). See conversation in dotnet/coreclr#21603

Signed-off-by: dotnet-bot <[email protected]>
2019-01-18 16:10:00 +01:00
Marek Safar 18ca997ac9 Fix defines in TaskAwaiter (dotnet/corert#6846)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-18 16:10:00 +01:00
Filip Navara 292c674043 Split ContractsBCL into separate classes and move them to shared CoreLib (#22006)
* Split up ContractsBCL into separate classes.

* Move remaining Contract, ContractHelper code to shared partition.

* Split ContractHelper to allow custom debugging experience in CoreRT.

* Simplify ContractHelper.InternalContractFailed.

* Use resource loading code from CoreRT.

* Remove unused parameter.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-18 15:36:44 +01:00
Maxim Lipnin 1c4a35efc3 Add TypeConverter fallback to DefaultValueAttribute (#12412)
Requires https://github.com/mono/corefx/pull/235.

Fixes https://github.com/mono/mono/issues/12362.
2019-01-18 15:22:58 +01:00
Alexander Köplinger 4741e44109 Fix tarball build 2019-01-18 14:37:52 +01:00
Atsushi Eno 72d7b3365b [wasm] fix insufficient csc arguments in sample README (#12493)
There would be newer build instruction with msbuild sdks but so far fix current readme.
2019-01-18 13:20:03 +01:00
Aleksey Kliger 9d697e9c5f Don't hardcode "mscorlib" use MONO_ASSEMLBY_CORLIB_NAME or mono_is_corlib_image
Use the MONO_ASSEMBLY_CORLIB_NAME define instead of hardcoding "mscorlib"
everywhere.  If building for netcore, the define is set to
"System.Private.CoreLib" instead.

In some circumstances, a string comparison against assembly->aname.name is used to
check if something is in corelib.  In cases like that, instead use
`mono_is_corlib_image (assembly->image)` instead.  (This introduces a
dependency on mono_defaults.corlib being correctly initialized, so it's
inappropriate for code that runs very early during startup.  Which I checked as
best I could.)

This should fix every use of literal "mscorlib" in the runtime.

This does _not_ fix every use of literal "mscorlib.dll" in the runtime, partly
because some of those uses are in the Framework-specific codepaths in the
loader and it doesn't necessarily make sense to perturb them.
2019-01-17 21:32:14 -05:00
Marek Safar 2c6ec113ff [System.Private.CoreLib] Initial build pass (#12450)
* [System.Private.CoreLib] Initial build pass

* Add temporary files not officialy converted to allow to build the library

* Formatting changes

* master rebase

* Fixes build

* Doc tests update

* Bump API snapshot submodule
2019-01-17 23:25:23 +01:00
Stephen Toub 09e9ffa65e Clean up a few minor Span-related uses (dotnet/coreclr#22038)
Some unnecessary Span to ReadOnlySpan casts.
Some places where new Span(...).Slice(...) can be replaced with AsSpan(...).
Etc.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-17 22:45:03 +01:00
Stephen Toub d4d6122008 Avoid allocations in Utf8Formatter.TryFormat(float/double, ...) (#22011)
* Avoid allocations in Utf8Formatter.TryFormat(float/double, ...)

Currently every call to Utf8Formatter.TryFormat for a float or a double allocates two strings, one for the format string and one for the resulting number.   This avoids those in the common case where we can use float/double.TryFormat and format directly into a stack buffer.  Also removes some unsafe code; the performance of StandardFormat.ToString isn't currently worth the extra nanoseconds gained by using unsafe code.

* Delete assert

There's a test that uses unsafe code to cause this to fail and validate that no exception is thrown.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-17 22:38:25 +01:00
Alexander Kyte b69ae3049e Merge pull request #12058 from alexanderkyte/fixup_aot_paths_host
[runtime] Don't probe aot cache on android
2019-01-17 16:12:42 -05:00
Zoltan Varga 09f3c2b8e1 [llvmonly] Refactor llvmonly runtime support code by moving it to a separate file. (#12436)
* [llvmonly] Move all runtime support code to a new llvmonly-runtime.c file.

* [llvmonly] Make mini_init_delegate () work in mixed mode, it needs to initialize both the interp and the llvmonly related data.

* [llvmonly] Implement EH support in mixed mode.

On interp->native transitions, add a try-catch. On native->interp transitions, rethrow the exception using a c++ throw.

* [llvmonly] Unify function naming, name all llvmonly runtime functions mini_llvmonly_.

* Fix a build failure.

* Fix windows build.

* Fix an aot failure.

* Fix the EH changes.
2019-01-17 13:16:36 -05:00
Marek Safar d864752ea0 Fix AsyncMethodBuilder build on Mono (dotnet/coreclr#22034)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-17 17:51:24 +01:00
Kenneth Pouncey dd5f9b8659 [wasm] Fix crash with delegates. (#12464)
Internally the javascript bridge support uses `System.Delegate` and `System.Delegate.DynamicInvoke` to support delegate callbacks.  The linker, when executed over the assemblies, does not know about this code coverage and will strip out `System.Delegate.DynamicInvoke`.

To fix this:

- Add reference to `System.Delegate.DynamicInvoke` to the `WebAssembly.Bindings` linker xml file so the linker knows not to strip the code.
- Add detailed error messages in case something else goes wrong so the crash is not so cryptic.
2019-01-17 15:43:24 +01:00
Marius Ungureanuandbaulig 6e28675564 Update mcs/class/System/System.IO.Compression/DeflateStream.cs
Co-Authored-By: baulig <[email protected]>
2019-01-17 15:00:25 +01:00
Martin Baulig 5068c7cc13 [System.IO.Compression]: Correctly handle exceptions in inner stream. #12205.
DeflateStream now correctly handles exceptions thrown by it's inner stream and
rethrows them after returning from native code.
2019-01-17 15:00:25 +01:00
Bernhard Urban 5625d51903 [.gitignore] recently added targetwatch64_32 2019-01-17 14:15:39 +01:00
Filip Navara 90ca7ea980 Fix CoreCLR build of AsyncMethodBuilder.
Signed-off-by: dotnet-bot <[email protected]>
2019-01-17 14:15:13 +01:00
Kirill Osenkov 98bfa5d904 Fix https://github.com/mono/mono/issues/12461.
After .NET 4.5 .NET Framework has changed the System.ComponentModel.Composition ReflectionModelServices.IsExportFactoryImportDefinition to not throw.

Updating this to match the .NET Framework behavior.
2019-01-17 12:05:10 +01:00
Ben Adams 19d3a157f4 Reduce steps for string.Contains(string value) (dotnet/coreclr#22008)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-17 09:28:07 +01:00
Marek Habersack eebe4b5285 [Android,AOT] Support dumping AOT offsets with Android NDK r17+ (#12454)
The latest Android NDK releases no longer ship with per-platform C headers.
Instead they ship with a set of unified headers and require the presence of the
`__ANDROID_API__` macro in order to select the target platform.
The AOT offset dumper doesn't support this new layout and this commit changes
that by adding support for the unified headers (without removing support for the
older NDKs) thus fixing the following error when trying to dump the offsets with
newer NDK:

    Processing triple: aarch64-v8a-linux-android
    Error parsing '[...]/mono/mono/metadata/metadata-cross-helpers.c'
    [...]/mono/mono/metadata/metadata-cross-helpers.c(5,10): fatal: 'stdio.h' file not found
    Error parsing '[...]/mono/mono/mini/mini-cross-helpers.c'
    [...]/mono/mono/mini/mini-cross-helpers.c(7,10): fatal: 'stdio.h' file not found
2019-01-16 23:57:01 +01:00
Bernhard Urban c8b6e6a8ff [arm64_32] use emulate OPs so it works with bitcode compiled code for armv7k (#12443)
[arm64_32] use emulate OPs so it works with bitcode compiled code for armv7k
2019-01-16 14:15:48 -05:00
Filip Navara f83d82c76f Move AsyncMethodBuilder to shared. (dotnet/corert#6832)
* Move AsyncMethodBuilder to shared.

* Bring back PROJECTN.

* #if-out TrackAsyncMethodCompletion for CoreRT.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-16 19:53:03 +01:00
Alexander Kyte 78af5ccc19 [runtime] Don't define build config dir on android (#12056)
* [runtime] Don't define build config dir on android

* [runtime] Don't look for files in unset mono_get_config_dir
2019-01-16 12:32:57 -02:00
Alexander Köplinger 230c2a7103 Add .gitignore for mono/tests/llvmonly-mixed 2019-01-16 15:02:53 +01:00
Marek Safar c797248624 [build] Add dotnet launcher bridge to the runtime (#12416)
Initial pass on settings this up (it works but using system Mono assemblies only)

Naming nitpicks are welcomed ;-)
2019-01-16 14:39:23 +01:00
monojenkins 6fabd0fbb7 [bcl] Update BCL Linked Size 2019-01-16 14:35:05 +01:00
Alexander Köplinger a7cf1beb8a Revert "Improve github issue template"
It's actually on purpose so we don't get annoying task progress indicators in the issues list.
2019-01-16 14:21:06 +01:00
Alexander Köplinger 6c2ab0edff Improve github issue template 2019-01-16 14:07:46 +01:00
Kenneth Pouncey 0c4d525eb8 [wasm] Build target fixes (#12418)
- Add linker xml descriptor to WebAssembly.Bindings and WebAssembly.Net.Http
   - The XML linker descriptor will keep the full assembly for these assemblies during link.

- Fix Link Assemblies command line.
   - Miscellaneous fixes for how the assemblies are linked whether they are framework or facades.
   - Add the Facades directory to the resolve paths.
2019-01-16 11:40:37 +01:00
Jan Kotas ed6041b7cf String -> string
Signed-off-by: dotnet-bot <[email protected]>
2019-01-16 09:52:55 +01:00
Marek Safar c404a499ad Move more COM exceptions to shared partition (dotnet/corert#6829)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-16 09:46:53 +01:00
Zoltan Varga 4d57a5786a [wasm] Linker changes. (#12433)
* [wasm] Add support for v8 style options to the packager, i.e. --option/--no-option.

Add a --linker option to turn on linking in interpreter mode.

* [wasm] Add a print-table.py helper script to print out the function table of a wasm module.

* [runtime] Add a --print-icall-table option to dump the icall table as json. Usable for linking the icall table.

* [runtime] Pass the method to the icall table lookup function.
2019-01-16 03:36:13 -05:00
Alexis Christoforides b79a9e7383 [fullaotinterp/fullaotinterp_llvm] Use CoreFX System.IO (#12386) 2019-01-16 10:02:00 +02:00
Miguel de Icaza b748dd14a2 [mini] re-enable LLVM for Linux JIT (#12420)
[mini] re-enable LLVM for Linux JIT

This re-enables the Linux JIT as suggested in https://github.com/mono/mono/issues/12030
2019-01-15 20:15:35 -05:00
Zoltan Varga 12e3cf9f5a [arm] Set the LLVM data layout, without it, opt seems to make incorrect optimizations. (#12429)
* [arm] Set the LLVM data layout, without it, opt seems to make incorrect optimizations.

Fixes https://github.com/mono/mono/issues/12307.

* [x86] Set the LLVM data layout.
2019-01-15 18:57:36 -05:00
Calvin Buckley 324d372168 Bump CoreFX for AIX/FileSystemEnumerator fix (#12375) 2019-01-15 19:40:01 +01:00
Jo Shields 33860df038 Merge pull request #12272 from nealef/context
Cater for later glibc use of ucontext
2019-01-15 11:46:47 -05:00
Jonathan Chambers d0e984aca3 Fix reentrant exception handling. (#12342)
Store handled status in local that is passed into
handler rather than a single thread local value
which can be overwritten in case of reentrance.
2019-01-15 16:56:14 +01:00
Johan Lorensson f4c4372901 Merge pull request #12317 from lateralusX/lateralusX/fix-warning-errors-win64-platform
Fix warning and build errors triggered in win64 platform that doesn't define HAVE_CLASSIC_WINAPI_SUPPORT.
2019-01-15 07:38:20 -05:00
Vlad Brezae 39c8e693f8 [interp] Remove unreachable code (#12411)
We throw exception directly from child frame if the transform phase fails.
2019-01-15 12:59:38 +02:00
Thays Grazia 41eb902535 [Debugger] Debugger failure when field content is assigned by an unsafe value (#12394)
* [Debugger] Debugger failure when a method is called in watches and any field of the Class has the type of the field different of the value of the field because the assign was done in an unsafe way like this:
Now the datatypes check in the fields are only executed when it's not inside an invoke method.
_pinnable = Unsafe.As<Pinnable<T>>(array);
A unit test that reproduces the issue was created either.
Fixes #12374
2019-01-15 07:51:16 -02:00
Zoltan Varga 3e3a2f51dd [wasm] Delete an unused CFLAGS assignment. (#12413) 2019-01-15 04:26:36 -05:00
Tarek Mahmoud Sayed dd9265c8f7 Fix TimeSpan parsing (dotnet/coreclr#21968)
* Fix TimeSpan parsing

* Temporary disabling the failed CI tests

Signed-off-by: dotnet-bot <[email protected]>
2019-01-15 08:57:02 +01:00
Aleksey Kliger 67c5a87ace [threads] Use refcounts for coordinating finalization and detaching
Reverts a29ad08d00 (#9914)

The basic problem we want to solve is the following:
  1. All access to InternalThread:state must be protected by the
     InternalThread:synch_cs mutex
  2. We must destroy the mutex when we are done with the thread.
  3. We don't know which happens later - detaching the machine thread or
     finalizing its InternalThread managed object.

The solution is to replace InternalThread:synch_cs by InternalThread:longlived
which is a refcounted struct that holds the synch_cs.  The refcount starts out
at 2 when the thread is attached to the runtime and when we create the managed
InternalThread object that represents it.
Both detaching and finalizing the managed object will decrement the refounct,
and whichever one happens last will be responsible for destroying the mutex.

This addresses https://github.com/mono/mono/issues/11956 which was a race
condition due to the previous attempt to fix this lifetime problem.  The
previous attempt incorrectly used CAS in mono_thread_detach_internal while
continuing to use locking of synch_cs elsewhere. In particular
mono_thread_suspend_all_other_threads could race with
mono_thread_detach_internal: it expects to take the thread lock and test
thread->state and use the thread->suspended event, while detaching deletes
thread->suspended without taking a lock.

As a result we had a concurrency bug: in suspend_all_other_threads it's
possible to see both the old (non-Stopped) value of thread->state and the
new (NULL) value of thread->suspended.  Which leads to crashes.

---

Background - why we don't know if detaching or finalization happens first.

1. InternalThread normally outlives the machine thread. This can happen because
when one thread starts another it can hold a reference to the fresh thread's
Thread object which holds a reference to the InternalThread. So after the
machine thread is done, the older thread can query the state of the younger
Thread object. This is the normal situation.

2. During shutdown we can have the opposite situation: the InternalThread
objects are finalized first (this happens during root domain finalization), but
the machine threads are still running, and they may still return to
start_wrapper_internal and call detach_internal. So in this case we have an
InternalThread whose finalizer ran first and detach will run second.
2019-01-14 19:29:09 -05:00
Marek Safar 00437dc590 [corlib] Add tracking exception for not object based type hierarchies 2019-01-14 20:38:19 +01:00
lateralusX 4e3ec6540d Review feedback and smaller adjustments to HAVE_API_SUPPORT_WIN32_* defines. 2019-01-14 19:09:18 +01:00
Alexander Kyte 21a0053638 [runtime] Fix jemalloc support (#12388) 2019-01-14 14:59:30 -02:00
Alexander Köplinger 1db473d810 Fix tarball build 2019-01-14 17:48:22 +01:00
Alexander Köplinger 311d1952af [bcl] Embed Source Link information (#12403)
Source Link allows IDEs/debuggers to retrieve a source file from a remote location like GitHub when the local file isn't available.

Specification: https://github.com/dotnet/designs/blob/e55c517a1e7f8dc35b092397058029531209d610/accepted/diagnostics/source-link.md

For now we only embed info about mono, cecil, corefx and corert since that covers 99% of what you usually want to debug and doesn't need fancy logic that reads git submodules and figures out their URLs.

Should enable use cases like https://twitter.com/jlaban/status/1084248087802060801
2019-01-14 15:16:31 +01:00
ShonkyCH b2ec37efde Fix cross compile issue introduced in 5.16 (#12267)
Fix cross compile issue introduced in 5.16

Fixes #9951
2019-01-14 05:35:36 -05:00
Thays Grazia 141bec26a5 [Debugger] Fix crash when there is a generic struct with a field that is an enumerator. (#12368)
* [Debugger]  Debugger crashes when inside a class, there is an internal struct, with a field that is an enumerator.
files.myBucket.GetEnumerator().get_Current().Key
Fixes #10735

* [Debugger] Debugger crashes when there is a generic struct with a field that is an enumerator.
Example: files.get_Current().Key
A unit test that reproduces this crash was added too.
Fixes #10735

* Removing the extra space.
2019-01-14 11:16:20 +01:00
Zoltan Varga 749e93c33c [llvmonly] Mixed mode changes. (#12383)
* [wasm] Add support for llvmonly+interp mixed mode.

* Add new --aot-interp and --aot-assemblies= options to packager.exe.
  The former enables mixed mode, the latter specifies the list of assemblies which will be AOTed.
* Set the proper AOT_MODE and link in interp libraries in the driver when mixed mode is enabled.

* [llvmonly] Add beginnings of support for llvmonly+interp mixed mode. Treat cross assembly calls as possible places where execution can transition to the interpreter.

* [llvmonly] Add mixed mode tests.

* [llvmonly] Return NULL from mono_jit_compile_method_with_opt () if a method is not found in mixed mode, the caller needs to handle it.

* Implement interp entry support for delegate invokes.

* Implement interp entry for virtual calls.

* Implement interp entry in virtual delegate calls.

* Implement interp entry for virtual generic calls.

* Add runtime invoke test.

* [llvmonly] Add a mini_llvmonly_load_method () helper function to reduce the amount of duplicated code.

* [llvmonly] Add a mini_llvmonly_load_method_delegate () helper function.

* Fix the checked build.
2019-01-14 05:15:16 -05:00
Zoltan Varga 1291c08c1d [runtime] Revert part of fc5800b30d, it breaks ios, which seems to have AppDomain.Unload (). (#12398) 2019-01-12 10:06:54 -05:00
Zoltan Varga fc5800b30d [runtime] Disable more code on wasm. (#12379)
* [runtime] Add a 'cleanup' --enable-minimal option to disable the shutdown cleanup code on platforms which don't need it. Enable it on wasm.

* [wasm] Disable mdb support in the device runtime.

* [runtime] Disable appdomain creation/unload icalls if DISABLE_APPDOMAINS is set.
2019-01-11 17:53:02 -05:00
Zoltan Varga 9047295678 [runtime] Register the GC alloc icalls during startup instead of on-demand, since create_allocator () might not be called at runtime in llvmonly mode if the generated code directly calls its wrapper. (#12381) 2019-01-11 17:25:30 -05:00
Stephen Toub 73b2c87dee Add missing overrides to SyncTextWriter (dotnet/coreclr#21956)
Several recently added virtuals to TextWriter were missing overrides on SyncTextWriter.

We were missing overrides of the synchronous `Write(ReadOnlySpan<char>)` and `WriteLine(ReadOnlySpan<char>)` overloads.  The impact here is primarily performance, though it'll still be an observable change in corner-case scenarios: rather than using the base implementation which would copy the span to an array and then invoke the properly overridden array-based Write{Line} methods, it'll now just delegate to the wrapped span methods.  So it calls the correct overload now on the wrapped instance, and saves some cost in the process.

We were also missing overrides for the async `WriteLineAsync()`, `WriteAsync(ReadOnlyMemory<char>, CancellationToken)`, WriteLineAsync(ReadOnlyMemory<char>, CancellationToken)` overloads.  Fixing these doesn't change the overload that's invoked on the wrapped writer, but it does cause the calls to become synchronous rather than queue a task that in turn calls the synchronized overload.  Whether the new behavior is better is arguable, but it keeps it consistent with every other XxAsync method on SyncTextWriter, which in my opinion is more important... if we wanted to alter the behavior for all of the XxAsync methods, we should do it for all of them.

Also, in the StringBuilder-based overrides, we were ignoring cancellation.  And in the recently added DisposeAsync, we should follow-suit with the rest of the async APIs and make it synchronous.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-11 23:17:52 +01:00
Zoltan Varga f14c5ca370 [wasm] Don't make aot-dummy.dll an output of the linker. (#12380) 2019-01-11 14:57:59 -05:00
Eberhard Beilharz 7952489bd2 [swf] Fix dispose of panels in StatusBar (#12355)
This change implements disposing of the panels of a status bar.
2019-01-11 13:21:28 +01:00
monojenkins 1e0bb426c7 [csproj] Update project files 2019-01-11 11:55:09 +01:00
Katelyn Gadd cc73cba992 Rearrange sources files to work around limitations of gensources/xtest integration 2019-01-11 11:55:09 +01:00
Katelyn Gadd b6d5b0e093 Disable the named pipe tests on win32 due to OnNativeIOCompleted issue (7500?) 2019-01-11 11:55:09 +01:00
Katelyn Gadd 6d7167f2f6 Ignore enotconn error results from the socket shutdown API 2019-01-11 11:55:09 +01:00
Katelyn Gadd 5834d7acc6 Move UnixDomainSockets pipe test to only run on linux net_4_x since it seems like it basically will only work there 2019-01-11 11:55:09 +01:00
Katelyn Gadd 1199c999ab Disable two test files for issue #12324 2019-01-11 11:55:09 +01:00
Katelyn Gadd c36000e83b Exclude unix domain socket tests from wasm profile 2019-01-11 11:55:09 +01:00
Katelyn Gadd 31a7a3ff29 Split unix build profile sources file out 2019-01-11 11:55:09 +01:00
Katelyn Gadd dd9160a464 Don't throw in pipestream's finalizer. Include named pipe support in the build profile. 2019-01-11 11:55:09 +01:00
Katelyn Gadd c5decd8c09 Throw an argument out of range exception when a pipe name is too long and specify which argument is out of range. Fixes a corefx test. 2019-01-11 11:55:09 +01:00
Katelyn Gadd 71e7273634 Enable named pipe tests 2019-01-11 11:55:09 +01:00
Katelyn Gadd 26b12f68ff Enable geteuid and seteuid so csc compiler server works 2019-01-11 11:55:09 +01:00
Zoltan Varga 141e1e48a5 [wasm] Compile the wasm runtime using optimization. (#12367) 2019-01-11 04:39:11 -05:00
Stephen Toub 4ff1c28c3f Add WithCancellation for async enumerables (dotnet/coreclr#21939)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-11 10:13:43 +01:00
Vlad Brezae 60d34d95c7 [interp] Fix resuming into interp when finally throws exception (#12328)
We might need to adjust the ip in the same fashion when normally resuming to catch handler.

In the example from the testcase, we have these transitions : ... -> interp_frame -> jit -> eh1 -> interp_frame -> eh2. When eh1 unwinds to call the finally clause from interp_frame it also pops all other lmf entries until there. This means that eh2 thinks it was called directly from the interp_frame (as it would happen with the jit), but in this case there are still the jit frames in the middle. Eh2 doesn't know how to resume over the jit frames, it will just set the resume state to the interp_frame and eh1 will do the resuming over the jitted frames, after run_finally returns gracefully. If the exception were to be handled by frames parent to interp_frame and there are also pushed contexts on the lmf stack, then eh2 could both unwind and resume directly there, skipping eh1 and the jitted frames altogether.
2019-01-11 09:44:04 +02:00
Marek Safar d8690f8f83 Move public interface ISymDocumentWriter to shared location (#21931)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-11 08:15:57 +01:00
Alexis Christoforides bae33bb447 Bump corefx 2019-01-10 16:08:48 -05:00
Marek Safar 5ba3db2155 Move COMException to shared partition (dotnet/corert#6803)
* Move COMException to shared partition

* Review feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-01-10 22:02:45 +01:00
Marek Safar 56e0b9448b Moves EnvironmentVariableTarget enum to shared partition (#21930)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-10 19:07:21 +01:00
monojenkins ab184eb52a [csproj] Update project files 2019-01-10 18:09:26 +01:00
monojenkins 753eaf9641 Bump API snapshot submodule 2019-01-10 18:09:26 +01:00
Maxim Lipnin 7e737e7cc4 Fix unrelated build issues 2019-01-10 18:09:26 +01:00
Maxim Lipnin 45fdf3d7f7 Bump corefx 2019-01-10 18:09:26 +01:00
Ben Adams d9389fa2e1 Move restoring ExecutionContext out of generic methods (#21909)
* Move restoring ExecutionContext out of generic methods

* Move one back

Signed-off-by: dotnet-bot <[email protected]>
2019-01-10 17:13:24 +01:00
Alexander Köplinger a707496149 Bump bockbuild 2019-01-10 16:30:35 +01:00
Kenneth Pouncey 1690b225ec [wasm] Cleanup Framework Bindings and HttpMessageHandler code. (#12326)
* Cleanup Framework Bindings and HttpMessageHandler code.

- move to framework folder to match package structure.  Simplifies packager code finding the framework libraries.
- create solution and project files
- split up the `bindings.cs`, now removed, into multiple files and reformat code
- Clean up xml documentation
- generate xml file documentation on build.
- modify make file to build the solution and modify tests to use framework output.
- modify `packager` to use the correct directory structure.
- modify `sdk` build targets.
- modify `package` target to package the correct assemblies along with source projects and solution.

Tested:

- JavaScript shell tests which run in jenkens
- Browser Tests
- AOT build and tests

* Modify projects to be netstandard instead of framework.

- use dotnet instead of msbuild which is not available.
- Modify test builds

* Fix Sdk.props to point to correct Bindings library path

* Fix build dependencies

* Fix AOT build - duplicate assembly key

* Fix package target
2019-01-10 15:53:05 +01:00
Martin Baulig edaa62f3a1 Misc AppleTls / BTLS exception and error check changes. (#12319) 2019-01-10 14:50:15 +01:00
monojenkins 59aa49b441 [bcl] Update BCL Linked Size 2019-01-10 13:37:11 +01:00
Alexander Köplinger a037a97cdf [Mono.Debugger.Soft] Keep existing crash files in Crash() test
Instead of deleting all, only delete the ones created by the test.
2019-01-10 12:28:39 +01:00
Levi Broderick baa8cf7312 Move OperationStatus into shared source (dotnet/coreclr#21912)
This is the first step to moving OperationStatus from corefx into coreclr. It'll be used by the transcoding APIs which live in System.Private.CoreLib.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-10 10:41:03 +01:00
Alexis Christoforides bb84dad457 [corlib] Fix monodroid build to reinclude CoreFX System.IO (#12057)
* [corlib] Fix monodroid build to reinclude CoreFX System.IO

* [corlib] Fix orbis and unreal builds to reinclude CoreFX System.IO

* [Mono.Native] Build on Android

* [csproj] Update project files

* Bump API snapshot submodule
2019-01-09 20:21:56 -05:00
Bernhard Urban ccc88a9971 [interp] use interp_lmf wrapper for interp2native on platforms with wonky sigcontext (#12293)
[interp] use interp_lmf wrapper for interp2native on platforms with wonky sigcontext

On some platforms (e.g. AppleTV) SigContext is available, but isn't as
precise as we would like to have it. For example, it doesn't save
callee-saved registers and thus aren't restored properly.

Unfortunately, this also means we can't use the fastpath for
interp2native, so we disable it on those platforms.


Needs backport to: 2018-08, 2018-10, 2018-12
2019-01-09 17:55:39 -05:00
Thays Grazia cb77514a94 [Debugger] Crash test (#12304)
* Changing the test behavior as discussed with Ludovic, because we already have knowledge about the unreliability of the crash reporter and the test is not about it.
So if in 10 times at least one of them works for now it's good.
Fixes #11385

* Removing extra message.

* Removing the crash log file after the test is finished.
2019-01-09 17:31:32 -02:00
Kenneth Pouncey cb16759b8a [wasm][ci] Re-enable chakra tests (#12332)
Re-enables the chakra tests now that the upstream jsvu issue was fixed.

Fixes https://github.com/mono/mono/issues/12331
2019-01-09 20:20:25 +01:00
Jan Kotas 0a8c290c5b More DispatchWrapper tweaks
Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 18:42:49 +01:00
Marek Safar 0f107837c0 Removes PNSE version of DispatchWrapper and keep only single version with ifdef
Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 18:42:49 +01:00
Jan Kotas 4114852a8b Delete files moved to shared partition
Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 18:42:49 +01:00
Aleksey Kliger 59f6251897 [coop] Move mono_threads_is_blocking_transitions_enabled to header
and make inline
2019-01-09 10:43:19 -05:00
Aleksey Kliger 99eeaab909 [coop] Drop support for MONO_ENABLE_BLOCKING_TRANSITION env var
It was never documented and it is not as useful now with a matured hybrid
suspend.

If MONO_ENABLE_BLOCKING_TRANSITION set, and mono is otherwise configured to use
preemptive suspend, the thread state machinery would perform RUNNING->BLOCKING
transitions (ie: MONO_ENTER_GC_SAFE and friends would be more than no-ops), but
still preemptively suspend every thread.  This was useful for testing the
thread transitions separately from the coop suspend details.
2019-01-09 10:43:19 -05:00
Zoltan Varga a19f9d869d Bitcode mixed mode work. (#12312)
* [llvmonly] Avoid generating/loading trampolines in llvmonly+interp mode.

Add a new execution mode MONO_AOT_MODE_LLVMONLY_INTERP and make --llvmonly-interp use that. INTERP_LLVMONLY defaults to the interpreter, while LLVMONLY_INTERP defaults to aot.

* [llvmonly] Save whenever a method has a gsharedvt variable signature into the aot image and use that instead of looking up its MonoJitInfo, which is a perf problem since its done for all methods.

* Add a case to append_mangled_wrapper_subtype ().

* [llvmonly] Move initialization of delegate->method_ptr to mini_init_delegate (), pass a handle to the callback.

* [llvmonly] Allow --regression to work in mixed mode.

* [llvmonly] Set param names for gsharedvt in/out wrappers.

* [llvmonly] Use the dedup mangler for setting method names for gsharedvt in/out wrappers, shorten the names a bit.

* Revert "[llvmonly] Allow --regression to work in mixed mode."

This reverts commit d7838c1ce7dc0e3d7bfc3c7f01214224f561db90.

* Fix c++-isms.
2019-01-09 15:23:58 +01:00
Kenneth Pouncey 1be89d440c [wasm] Fix build target errors (#12314)
- Fix different errors when building via the nuget instead of locally.
- The nuget generated had a different structure so fixed the output generation to work for both local build as well as nuget build.
- Fix problem with the monolinker.exe not being located correctly.
- Move the monolinker.exe to tools directory within nuget.
2019-01-09 15:20:35 +01:00
Alexander Köplinger a947358007 Disable Chakra tests on wasm
https://github.com/mono/mono/issues/12331
2019-01-09 13:55:05 +01:00
Tomas Weinfurt c6b7d04096 fix DateTime overflow on ARM32 (dotnet/coreclr#21902)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 12:47:28 +01:00
Marek Safar 7897436a7e Moves common COM type to shared corelib partition (dotnet/corert#6782)
* Moves common COM type to shared corelib partition

* Moves GetHRForException to PInvokeMarshal

* Add temporary CORECLR ifdef to ArrayWithOffset

* Apply cleanup from CoreCLR

Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 10:01:33 +01:00
Stephen Toub c7785160c0 Expose string.Concat(ReadOnlySpan, ...) (dotnet/coreclr#21882)
* Expose string.Concat(ReadOnlySpan, ...)

* Add String.Empty fast path to string.Concat(ReadOnlySpan, ...)

Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 09:45:59 +01:00
Alexander Köplinger d8c75df45b Fixup wasm build
We need to also purge any changes done by emsdk
2019-01-09 01:57:20 +01:00
Alexander Köplinger 2bb95a4990 [wasm] Fix build when emsdk repo is dirty
We hit the following issue when the upstream repo receives a new commit:

```
16:11:49 error: Your local changes to the following files would be overwritten by merge:
16:11:49     binaryen-tags.txt
16:11:49     emscripten-tags.txt
16:11:49     upstream/lkgr.json
```

To workaround we now clean the emsdk repo before pulling.
2019-01-08 18:40:15 +01:00
lateralusX 4486952c2f Fix build error when doing MSVC build wihtout cygwin not having a config.h. 2019-01-08 15:01:48 +01:00
Martin Baulig 78cca25b44 Move ENABLE_GSS conditional into System; fixes #12263. (#12303)
Should fix #12263.
2019-01-08 14:33:38 +01:00
lateralusX 46a1c80a41 Fix warnings and build errors when bumping Mono on alternative Windows platforms.
Several of the name changes fixes MSVC warnings where local variables
hides global variables using the same name.

Number of adjustments not building on platforms not defining HAVE_CLASSIC_WINAPI_SUPPORT.

Fix a couple of build projects not setting dependencies on build-init.vcxproj.
This could cause races in build order if projects depend on build initialization.

Added support to force external builds to use msbuild even if ninja is present.
2019-01-08 14:06:14 +01:00
Thays Grazia 0b6eff6ed4 [debugger] Fix test ShouldCorrectlyStepOverOnExitFromArgsAfterStepInMethodParameter (#12114)
The problem was in this line:
ss_nested_with_two_args(ss_nested_arg (), ss_nested_arg ());
The first step_into works correctly entering in the ss_nested_arg method, but the second one doesn't work.
The problem was because this flag MONO_SEQ_POINT_FLAG_NONEMPTY_STACK was set, so the debugger don't consider that it was a possible break.
The solution of the issue was create another flag to identify nested calls and ignore the  MONO_SEQ_POINT_FLAG_NONEMPTY_STACK.
2 new tests were added to test other nested calls.
#Fixes 7326
2019-01-08 09:47:04 -02:00
Dan Moseley b9e209fc93 Fix path length 255 (dotnet/coreclr#21838)
* Fix path length 255

* Fix assert

* Dead code

Signed-off-by: dotnet-bot <[email protected]>
2019-01-08 08:40:23 +01:00
Jan Kotas de75ac8c6f CoreRT updates for files moved to shared partition
Signed-off-by: dotnet-bot <[email protected]>
2019-01-08 08:40:23 +01:00
Marek Safar 84d992cfd7 Moves ComTypes to shared partition (dotnet/coreclr#21861)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-08 08:35:32 +01:00
monojenkins 07dc55c8c4 [bcl] Update BCL Linked Size 2019-01-08 08:29:43 +01:00
Zoltan Varga fea1723e40 [wasm] Enable Mono.Native. (#12143)
* [wasm] Add stubs for a few functions needs by System.Native.

* [wasm] Enable Mono.Native.

* Enable Mono.Native in the mono build.
* Link libmono-native.a into the interpreter/aot builds.
* Add a dlopen fallback to driver.c to allow the runtime to look up the pinvoke declarations.

* [wasm] Enable direct pinvokes for AOT, disable the dl fallback in AOT mode, its not needed since the generate code links directly to the Mono.Native symbols.

* [wasm] Disable more corlib tests for wasm.

* [wasm] Enable running corlib tests on CI.

* [wasm] Pass -D_WASM_ to the Mono.Native build.

* Fix line numbers in stack frame tests.

* Revert "[wasm] Enable direct pinvokes for AOT, disable the dl fallback in AOT mode, its not needed since the generate code links directly to the Mono.Native symbols."

This reverts commit 2d2ba5261c6fa0b6c1c110d53f18c4248c11cdff.

Direct pinvokes need more support since it needs to link against objc-libs, btls, etc.

* [csproj] Update project files
2019-01-07 19:00:17 -05:00
Aleksey Kliger (λgeek) 988f4a2147 [mini] Use C++ linker iff building C++ that needs the C++ runtime (#12266)
* [mini] Use C++ linker iff building C++ that needs the C++ runtime

(This has nothing to do with --enable-cxx.  This is about our LLVM .cpp files).

Explicitly set the linker for libmini.  The issue is that the automatic
linker selection (See
https://www.gnu.org/software/automake/manual/html_node/How-the-Linker-is-Chosen.html)
looks at all the _SOURCES for a target, even those that are only
conditionally added, even if the condition is false.  So because we sometimes
build mini-llvm-cpp.cpp we always get the c++ linker.  But that's not what we
want.

The goal is:
 - if there's any C++ code included into mono (either the shared lib or a
   program) that needs the C++ runtime library, ensure that we link using the C++
   linker.  This was already true, we just need to make sure it stays true.
 - if mono is built in such a way that it has no C++ code in it (that needs the
   C++ runtime library), ensure that we link with the C linker and without
   including the C++ runtime library.
   This will address issues like https://github.com/mono/mono/issues/12060

We do this in two steps:

1. We split out all the c++ source code to libmini-cxx.la and include that into
   libmini.la.

   That's enough to force C++ linking if libmini-cxx.la has any code in it.  If
   there's no C++ code (right now that means there's no --enable-llvm or
   --enable-llvm-runtime), we don't add libmini-cxx.la and all the C source in
   libmini links in the normal manner.

2. We have a hack where we sometimes include libmono.a (the static library)
   into the mono executable.  In that case, we could forget about the C++
   linker (which leads to build failures because llvm uses all the C++ runtime
   library stuff that we forgot to link in).

   So we use the "nodist_EXTRA_..._SOURCES=dummy.cpp` hack to make it look like
   the mono executable has C++ source, which in turn forces the use of the C++
   linker.

   The conditional logic here has to match exactly what we do for deciding
   whether to add libmini-cxx.la into libmini.la.  If we do, then force the use
   the C++ linker here.

   It may seem like another option is to use something like
   `mono_boehm_LINK=$(CXXLINK)` to set a target-specific linker.  But this is
   bad, actually, because in that case we will drop the `..._LDFLAGS` and other
   linker flags unless we're very diligent to include all of them.  The
   `nodist_EXTRA_..._SOURCES` hack is more resilient because automake will
   ensure that all the flags are kept.

* [llvm,wasm] Don't add -lstdc++ in llvm_config.mk

Leave it to the linker.

This is needed when building wasm cross compilers for windows which pass
-static-libstdc++ to configure.  As a result we would get duplicate symbols by
linking against a static libstdc++.a and also the export stubs of libstdc++.dll

In mini, link monow using the C++ linker same as with mono by using the nodist_EXTRA_..._SOURCES
trick.

In wasm, pass -static-libstdc++ to CXXFLAGS, not LDFLAGS.  c++ linking picks up
CXXFLAGS anyway, and -static-libstdc++ has no effect on the C linker and it
doesn't affect explicit -lstdc++ flags anyway.
2019-01-07 17:51:31 -02:00
Marek Safar 65a2c8a396 Moves StackTrace to shared partition (dotnet/coreclr#21757)
* Moves StackTrace to shared partition

* Remove obsolete comment

* StackFrame::GetFileName behaves like property, remove SecurityException

* Adjust CoreRT ifdefs, fix names for consistency

Signed-off-by: dotnet-bot <[email protected]>
2019-01-07 18:45:48 +01:00
Bernhard Urban 333ad864c4 [ios] initial watch64_32 support (#11691)
* [ios] initial watch64_32 support

* align iOSSimulatorTemplate with iOSDeviceTemplate
2019-01-07 14:56:42 -02:00
Zoltan Varga 7d746ac405 [aot] Delete the automatically created temporary directory when using --aot=llvm. (#12294) 2019-01-07 11:37:43 -05:00
Jay Krell ad3a9fbba8 [Coop] Convert and cleanup open/create of named mutex/event/semaphore. (#12002)
* [Coop] Convert System.Threading.Semaphore.
Potential handles are avoided through fixed, but error path converting utf16 to utf8 is introduced.

* [Coop] Cleanup System.Threading.Mutex. Replace gchandle pinning with C# fixed.

* Remove two commented out lines that are not likely to materialize.

* [Coop] Cleanup System.Threading.NativeEventCalls. Replace gchandle with C# fixed.

* Don't assume ves_icall_System_Threading_Semaphore_ReleaseSemaphore_internal output is to stack.
2019-01-07 10:51:10 -05:00
Alexis Christoforides 96259e2b30 [tests] Remove an invalid assertion on System.IO.DriveInfo
All fixed drives are not guaranteed to be ready
2019-01-07 08:21:29 -05:00
Kenneth Pouncey 749a0825c3 [wasm] Fix build targets errors
- The "WasmLinkAssemblies" task could not be loaded from the assembly
2019-01-07 10:55:27 +01:00
Zoltan Varga 4d9bba73a2 Bump corefx to pick up wasm build changes. 2019-01-07 10:11:58 +01:00
Jan Kotas 1bd557004e Delete redundant S.R.InteropServices.PInvokeMap and S.R.InteropServices.PInvokeMarshal (#21831)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-07 09:42:38 +01:00
Ben Adams 18c632ed43 Maintain left.Equals(right) order for equality for compat (#21829)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-06 10:11:18 +01:00
Ben Adams 453de54075 (C#7) Use pattern matching is rather than as with null check (#21828)
* Use pattern matching `is` rather than `as` with null check

Signed-off-by: dotnet-bot <[email protected]>
2019-01-06 10:11:18 +01:00
Ben Adams d2fbbb9633 Remove redundant unsafe contexts (dotnet/coreclr#21826)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-06 09:52:56 +01:00
Mikayla Hutchinson 5abcf78484 [Wasm] Fix build targets packaging 2019-01-05 10:33:49 +01:00
Vlad Brezae ec1510e35f [exceptions] Always process self aborts even if we have one pending (#11927)
[exceptions] Always process self aborts even if we have one pending

For example, in the following code, the abort that ends the thread should be the one thrown from the finally block instead of the try block :

```csharp
try {
	Thread.CurrentThread.Abort ();
} finally {
	Thread.CurrentThread.Abort ();
	Console.WriteLine ("Why are you still here ?");
}
```
2019-01-04 19:25:33 -05:00
Jo Shields 0623e93aee Merge pull request #12271 from directhex/fix-configure-on-old-autoconf
Add explicit no-op to RISC-V FPU detection, to fix old Autoconf (RHEL 6)
2019-01-04 16:16:24 -05:00
Ben Adams 4c8bfc6555 Support faster null checks (dotnet/coreclr#21765)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 21:05:29 +01:00
Stephen Toub bef2df9ed6 Add StringExtensions.Concat to fix Microsoft.IO.Redist assembly
Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 20:59:20 +01:00
Neale Ferguson ed617f19ca Missing include 2019-01-04 13:36:42 -05:00
Neale Ferguson 5595d6c611 Cater for later glibc use of ucontext 2019-01-04 13:33:14 -05:00
Jo Shields e978b049a7 Add explicit no-op to RISC-V FPU detection, to fix old Autoconf (RHEL 6)
Apparently, on old versions of Autoconf, a AC_TRY_COMPILE block with an
empty action-if-true block, like:
```
        if test x$fpabi = xauto; then
                AC_TRY_COMPILE([], [
                        #ifdef __riscv_float_abi_double
                        #error "double"
                        #endif
                ], [
                ], [
                        fpabi=double
                ])
        fi
```
emits invalid shell code, like:
```
  (exit $ac_status); } && {
         test -z "$ac_c_werror_flag" ||
         test ! -s conftest.err
       } && test -s conftest.$ac_objext; then

else
```

`else` immediately after `then` is not valid.

This construct is fine on newer versions, where `then :` is used, which
does not count as invalid.

Even though we're not building for CentOS 6 RISC-V, the invalid shell
causes the configure script to fail entirely, e.g. https://jenkins.mono-project.com/view/Releases/job/ng-release-generate-rpm-packages/963/execution/node/142/log/

Add a useless action-if-true which won't affect the program flow, but
means we aren't emitting `then else` on old Autoconf.
2019-01-04 12:39:54 -05:00
Marek Habersack 60e1a3a63f [Android] Fix build with NDK r18 (#11016)
Xamarin.Android is looking to switch to using the latest Android NDK, r18.
However, there are a few build issues in Mono and BTLS which need to be
addressed before that happens.

  * BTLS fails to build some ARM assembly sources with NDK r18's clang.
    https://github.com/mono/boringssl/pull/12 fixes this issue

  * BTLS uses obsolete Android cmake toolchain file.
    Add a configure option to set alternative toolchain file.

  * NDK r18 minimu supported API level is 16.
    This commit makes the API level configurable and sets the minimum platform
    to API 16

  * NDK r18 makes changes to declaration of `mmap` which break Mono build.
    Detect NDK version in `mono-compiler.h` and act accordingly (do not
    redeclare `mmap`)

  * NDK r18 doesn't have `cpp` and SDKs build assumes it's present.
    Detect whether `cpp` is present and, if not, use `compiler -E` instead.

  * NDK r18 uses unified headers exclusively and requires __ANDROID_API__ to be
    set in order to present the correct set of native APIs.
    SDKs now define the macro when the `ANDROID_NEW_NDK` Make variable is set to
    anything else than `no`.
2019-01-04 11:58:14 -05:00
Aleksey Kliger (λgeek) 32074d1698 [coop] Add high level suspend policy accessors (#12116)
- mono_threads_suspend_policy_name
- mono_threads_suspend_policy_are_safepoints_enabled
- mono_threads_suspend_policy_is_multiphase_stw_enabled
- mono_threads_suspend_policy_is_blocking_transition_enabled

The normal accessors (mono_threads_are_safepoints_enabled, etc) just apply the
policy acessors to the current policy
2019-01-04 11:36:05 -05:00
Vlad Brezae f562e59d98 [sgen] Fix debug build (#12067) 2019-01-04 12:24:46 -02:00
Kenneth Pouncey 646515fd35 [wasm] Allow creation of JavaScript Objects. (#11970)
- Allow creation of JavaScript objects without resorting to json parsing and creating hooks.
- Small cleanup of the bindings routines.
- Modify WasmHttpMessageHandler to use new routines and take out the hackish calls.
2019-01-04 13:42:07 +01:00
Egor Bogatov 98b7d35110 Undo changes in ConditionalWeakTable.cs (#12261)
* undo cwt ns21

* implement AddOrUpdate
2019-01-04 12:25:00 +01:00
Mikayla Hutchinson 5f890cede3 Add WebAssembly MSBuild targets (#12221) 2019-01-04 11:51:37 +01:00
Bernhard Urban 21d77b319a [amd64] fix --enable-minimal=jit build (#12265) 2019-01-04 09:42:52 +01:00
Stephen Toub e2ecfe2410 Use ValueStringBuilder instead of StringBuilderCache in PathInternal.Windows.cs
Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 09:29:04 +01:00
Egor Bogatov 6db483c371 Eliminate some bounds checks in Path (dotnet/coreclr#21721)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 09:29:04 +01:00
Marek Safar 6e11c95a84 Adds portable version of EncodingTable (dotnet/coreclr#21735)
* Adds portable version of EncodingTable

Most of the implementation is extracted from CoreRT

* Use string comparer directly

* Remove no longer used COMNlsInfo

* Adds localization support

* Removes FeatureCoreFxGlobalization configuration

* Remove redudant encodings look up from GetEncoding

* Keep Hashtable for nameToCodePage as it does not lock on read

* Replace locked dictionary lookup with short switch

* Include comment with msbuild task link used to generate the data file

Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 09:29:04 +01:00
Stephen Toub 011610e440 Improve performance of Path.ChangeExtension (dotnet/coreclr#21766)
In the common case where it need to replace a non-empty extension with a non-empty extension, it currently incurs a substring without the original extension prior to then concatenating with the new extension.  This PR avoids that.

(As the Path implementation is in corelib, this uses string.FastAllocateString and then formats into it with a span; if we wanted to avoid that, string.Create could also be used.)

* Add internal String.Concat overloads for spans

* Use span-based string.Concat overloads in several places

Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 09:29:04 +01:00
Stephen Toub d3747f620b Reduce allocation in Index/Range.ToString (dotnet/coreclr#21755)
* Reduce allocation in Index/Range.ToString

* Address PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 09:16:57 +01:00
Martin Baulig e8f15493be Merge CoreFX with dotnet/release/2.2 (#11913)
* Trying to merge CoreFX with dotnet/release/2.2

* Disable some System.IO tests

* fix wasm build

* fix fse.notsupported

* Bump API snapshot submodule
2019-01-04 09:10:58 +01:00
Alexander Kyte 84276a51f7 [runtime] Enable interpreter to be used with --enable-minimal=jit (#12080)
[runtime] Enable interpreter to be used with --enable-minimal=jit
2019-01-03 15:45:43 -05:00
Aleksey Kliger (λgeek) 3a4b2b4a32 [coop] Make sure suspend_count is positive in suspend request states (#12241)
* Fix bug in pulse transition - the suspend count was lost and incorrectly
  swapped to 0.
* finish_async_suspend transition - add assertions that the suspend count is
  positive. Try to catch incorrect states sooner.

Fixes https://github.com/mono/mono/issues/12235
2019-01-03 11:23:13 -05:00
Vlad Brezae 1b242b8960 [interp] Fix resuming into interp frame during EH (#12092)
[interp] Fix resuming into interp frame during EH

During EH, we can have the same frame twice on the stack, the original one and when invoking clauses in the same frame from EH. When having a resume state, we need to check if we should catch it in the current frame, or the original.

<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2019-01-03 10:05:57 -05:00
Marek Safar 5b220bf1dc Updates codeowners 2019-01-03 15:17:27 +01:00
Jan Kotas ec9d78627d Cleanup current culture handling in the unmanaged runtime (#21706)
Large portion of the current culture handling in the unmanaged runtime inherited from desktop has been no-op. The nativeInitCultureAccessors QCall that it used to depend on desktop got (almost) never called in CoreCLR.

- Delete resetting of current culture on threadpool threads. It was needed in desktop because of a very tricky flow of current culture between appdomains. It is superseded by the flowing the current culture via AsyncLocal in CoreCLR.
- Comment out fetch of managed current culture for unmanaged resource lookup. It has number of problems that are not easy to fix. We are not localizing the unmanaged runtime currently anyway, so it is ok to just comment it out.
- Fix the rest to call CultureInfo directly without going through Thread.CurrentThread

Signed-off-by: dotnet-bot <[email protected]>
2019-01-03 15:06:47 +01:00
Stephen Toub 40ec59d65b Replace string.Format(SR. with SR.Format(SR. (dotnet/coreclr#21763)
We use SR.Format in almost all places where we format resource strings (without a format provider), but there were a few stragglers.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-03 09:58:07 +01:00
Stephen Toub 61530694c8 Change a couple string.Replace("a", "b") to string.Replace('a', 'b') (#21768)
The latter is functionally the same but less overhead.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-03 09:58:07 +01:00
Stephen Toub 4e16ade794 Use StringBuilderCache in PathInternal.NormalizeDirectorySeparators (#21760)
When we do need to normalize, we're currently allocating the StringBuilder/char[] for the full path length.  As long as the path length is less than the max cacheable size (360), we'll now use a cached builder.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-03 09:44:24 +01:00
Marek Safar 91ca78d698 Additional ifdef changes which are ES_BUILD_STANDALONE specific for System.Diagnostics.Tracing (#21748)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 23:08:47 +01:00
Stephen Toub c2a5e933bd Replace Array.Copy(src, dst, int) calls with Array.Copy(src, 0, dst, 0, int) (#21756)
The former calls GetLowerBound(0) on both src and dst, which is unnecessary when the arrays are T[] and thus always have a lower bound of 0.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 23:08:47 +01:00
Alexander Kyte 227e7119b7 Merge pull request #12126 from alexanderkyte/telemetry_blob
[crash] Support extra merp params
2019-01-02 12:14:35 -05:00
Jay Krell 6a9d38a2cb Change array construction with rank>4 to use not use varargs -- localalloc. (#12213)
* Change array construction with rank>4 to use not use varargs -- localalloc.
This fixes https://github.com/mono/mono/issues/12193.

This is alternative to https://github.com/mono/mono/pull/12200.
They are both pretty good approaches.
12200 uncovered a hash order dependency which should be fixed either way.

* Fix C++.

* Remove unused MONO_ARCH_VARARG_ICALLS and ARCH_VARARG_ICALLS.
2019-01-02 12:12:46 -05:00
Kenneth Pouncey 9f73df9441 [wasm] Add support to find the wasm framework libraries. (#12211) 2019-01-02 12:11:59 -05:00
Zoltan Varga 0e96ba6889 [llvm] Remove the linkonce code, its not used anymore. (#12173) 2019-01-02 12:11:16 -05:00
Jay Krell fc33a23c68 Remove MonoCompile.inlined_method. It is confusing to have so many MonoMethods in MonoCompile: (#12201)
```
typedef struct {
.
.
.
    MonoMethod      *method;
    MonoMethod      *inlined_method; /* the method which is currently inlined */
    MonoMethod      *current_method; /* The method currently processed by method_to_ir () */
    MonoMethod      *method_to_register; /* The method to register in JIT info tables */
} MonoCompile;
```
so at least remove one of them that is not really used.
2019-01-02 12:09:34 -05:00
Jay Krell 9b285bf28a Do not build up indefinite coop handles in loops. (#12206)
* Do not build up indefinite coop handles in loops.

https://jenkins.mono-project.com/job/test-mono-pull-request-acceptance-tests/11767/parsed_console/log.html
ves_icall_System_Threading_WaitHandle_Wait_internal_raw USED 107 handles

* Add const.
2019-01-02 11:45:23 -05:00
Jay Krell d966231f0a [Coop] Convert and consolidate {remoting,cominterop}type_from_handle. (#12178)
* Consolidate identical functions type_from_handle and cominterop_type_from_handle
mostly into mono_type_from_handle.
However keep them separate for registration/patching sake, since
will error if register twice, else need to arrange to register once.

* [Coop] Convert {remoting,cominterop}type_from_handle.

* Fix warning about missing icall declaratons.
2019-01-02 11:38:29 -05:00
Marek Safar 3de77f3c60 Moves Attribute instance bits to shared location (dotnet/corert#6747)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 16:46:39 +01:00
Filip Navara 5eb676ddea Remove dummy globalization implementation. (dotnet/corert#6756)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 16:37:27 +01:00
monojenkins caf22d5f0b [csproj] Update project files 2019-01-02 13:54:08 +01:00
Leonardo Galli 1746f09efe [build] Fixed csproj.tmpl for macos: Conflict in naming of HostPlatform.
macOS was used for checking HostPlatform for OSX, but darwin is what the value was set to. This fixes the solution and csproj files for OSX.
2019-01-02 13:54:08 +01:00
Jan Kotas 8383b2194b AppContext moved to shared partition - CoreRT specific changes
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 10:13:31 +01:00
Ben Adams 2586365035 strlen to managed code and vectorize (dotnet/coreclr#21729)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 10:13:31 +01:00
Marek Safar cd079b1cab Tweaks permissions ifdefs in System.Diagnostics.Tracing (#21733)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 10:13:31 +01:00
Marek Safar 02c1851501 Moves AppContext to shared location (dotnet/coreclr#21734)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 10:05:59 +01:00
Jay Krell 496eceef19 Register two separate functions for mono_fconv_u4 and mono_fconv_u8
instead of each function twice.

Elsewhere there is single instancing based on function address
and registering the same function twice breaks things.
2019-01-01 23:38:17 -05:00
Comical DERSKEAL e78eeecb33 Typo fix (#12230)
Typo fix


<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2019-01-01 16:15:39 -05:00
Jan Kotas 5a784c3cca Delete useless ArgumentNullException message (dotnet/coreclr#21728)
"Object cannot be null" does not add anything over the default "Value cannot be null"

Signed-off-by: dotnet-bot <[email protected]>
2019-01-01 10:01:05 +01:00
Dmitry Kalyanov d933418d23 Fix data race in System.Web.Caching by using appropriate lock level
System.Web.Caching.CacheItemLRU.this[string].get modifies LRU list so it
must be called under write lock. Cache.GetKeyLastChange violates this
constraint by acquiring only a read lock.

Fixes #12218
2018-12-31 15:36:36 -05:00
Marek Safar 326afd6eaf Moves ExceptionDispatchInfo to shared location (dotnet/coreclr#21725)
* Moves ExceptionDispatchInfo to shared location

* Use struct for Exception.DispatchState, avoid TLAs in names, misc cleanup

Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 21:07:53 +01:00
Jan Kotas c624667e2f Add license, keep more of the CriticalHandle logic in the shared file
Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 10:44:45 +01:00
Marek Safar c508d6d3c9 Moves CriticalHandle to shared location
Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 10:44:45 +01:00
Marek Safar c44a67cf03 Readability improvement in MemoryStream (dotnet/coreclr#21710)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 10:36:04 +01:00
Koundinya Veluri 66fc2bf37f Don't Sleep(1) in some spin-wait loops (dotnet/coreclr#21722)
- In spin-wait loops that are not expected to last too long, Sleep(1) significantly delays threads from completing the operation
- From eliminating Sleep(1) in such spin-wait loops, there can be a tradeoff, better fairness vs worse throughput, because Sleep(1) removes threads from contention and in some cases fewer threads can make faster progress at the cost of delaying the Sleep(1) threads relatively significantly. Eliminating the Sleep(1) in such spin-wait loops seems to be a good tradeoff.

Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 10:36:04 +01:00
Jan Kotas 3ea344432f Fix CoreRT build breaks
Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 10:36:04 +01:00
Thays Grazia 2a16c76733 [Debugger] Record time it took between steps. (#12217)
* When going to https://jenkins.mono-project.com/job/test-mono-pull-request-arm64/8921/testReport/junit/(root)/DebuggerTests/StackTraceInNative/ for example, we have no idea why the underlying process has exited. To figure it out, we need to go to https://jenkins.mono-project.com/job/test-mono-pull-request-arm64/8921/parsed_console/log_content.html#WARNING1 and scroll back up to where the test was executed to find out the debuggee process crashed with an assertion.
This was fixed by redirecting the StandardOutput and StandardError of the debuggee process in the Mono.Debugger.Soft test suite.

* [Debugger] Record time it took between steps.
I implemented a new message to avoid breaking the protocol. I used the MonoStopwatch to count the time between the steps, it was already used in the debugger-agent.
Fixes #8460

* Bump API snapshot submodule
2018-12-30 20:46:09 -05:00
Ben Adams 7315fc3d99 Shorter ExecutionContext.Capture (dotnet/coreclr#21707)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-30 19:26:51 +01:00
Marek Safar 081c438508 Moves generic comparers to shared CoreLib (dotnet/coreclr#21649)
* Moves generic comparer to shared CoreLib

* Keep Index/LastIndexOf optimizations in CoreCLR only

* Moved runtime-specific enum helper to runtime-specific partial type

Signed-off-by: dotnet-bot <[email protected]>
2018-12-30 10:55:01 +01:00
Marek Safar a2e68c76cd Moves ThrowHelper to shared location (dotnet/corert#6741)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-30 00:21:46 +01:00
Filip Navara 6900eb750e Move CultureInfo to shared CoreLib (dotnet/coreclr#21672)
* Move thread CurrentCulture and CurrentUICulture variables to CultureInfo.

* Move CultureInfo to shared CoreLib

* Code style fixes for consistency.

* Fold down APPX code into CultureInfo.CurrentCulture/CurrentUICulture.

* Remove unnecessary parentheses around return statements.

* Remove GetCurrentUICultureNoAppX.

Signed-off-by: dotnet-bot <[email protected]>
2018-12-29 22:49:33 +01:00
Egor Bogatov 34619669a5 Replace Interop.ReadDir.cs with Interop.ReadDir.cs from System.IO.FileSystem (#21622)
* Use Interop.ReadDir.cs from FileSystem (corefx)

* Use ArrayPool

* Remove ReadBufferSize (and static cctor)

* use NameBufferSize for 256 const

* Delete ReadDir and SafeDirectoryHandle.Unix.cs

* Introduce GetDirectoryEntryFullPath, remove uint casts

* Refactor EnumerateFilesRecursively

Signed-off-by: dotnet-bot <[email protected]>
2018-12-29 22:49:33 +01:00
Hugh Bellamy bd60819235 Remove dead Guid parsing code (dotnet/coreclr#21123)
* Remove dead checks in Guid parsing

* Minor cleanups in Guid

* Delete unused failureMessageFormatArgument

Signed-off-by: dotnet-bot <[email protected]>
2018-12-29 22:17:48 +01:00
Kenneth Pouncey a113c668a1 Add pupeteer to the browser tests node packages. (#12179)
- This will download the most recent version of headless to use.
- Add junit-reporter to output a tests output file to be used for jenkins CI in the future.
2018-12-28 10:05:51 -05:00
Kenneth Pouncey 07723a4772 [wasm] Update build docs (#12088)
* Update build docs

* Upate aot info
2018-12-28 08:45:32 -05:00
Jan Kotas 2d73d36997 Use common copy of System.Numerics.Hashing.HashHelpers
Signed-off-by: dotnet-bot <[email protected]>
2018-12-28 11:15:34 +01:00
Aleksey Kliger d1a5fa3783 [mini] Always emit safepoints, except WASM
This addresses https://github.com/mono/mono/issues/11765
2018-12-27 12:19:09 -05:00
Aleksey Kliger 0bf473d29c [marshal] Always emit blocking transitions, except WASM 2018-12-27 12:19:09 -05:00
Aleksey Kliger (λgeek) c1587b9f37 Reduce extern "C", in non-public headers. (#12148) 2018-12-27 09:32:57 -05:00
Jay Krell c09dda16ff ICALL_EXPORT reduction. (#12145)
ICALL_EXPORT should not be placed on HANDLES() functions.
Only the auto-generated wrappers need it, and they get it from the macro expansion.
And the explicit function declarations are generally redundant - the macro creates declarations, too.
2018-12-27 09:32:29 -05:00
Filip Navara 8f8289d444 Move Contracts.cs (CoreCLR version) to shared CoreLib and update code to compile. (#6734)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-27 15:18:55 +01:00
Filip Navara d9c30acd8e Move System/Numerics/Hashing to shared CoreLib. (dotnet/corert#6732)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-26 23:04:30 +01:00
Filip Navara d559dc6b66 Move DebugProvider.Windows to shared CoreLib. (dotnet/coreclr#21657)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-24 14:29:23 +01:00
Ben Adams db8add85e6 Use TZCNT and LZCNT for Locate{First|Last}Found{Byte|Char} (#21073)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-24 11:06:37 +01:00
Michal Strehovský 4f456991bc Fix ProjectN regression in ByReference<T> (dotnet/corert#6713)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-24 00:32:27 +01:00
ichensky 92c2fab68e Add optimization in GetHashCode for Int16 and SByte (dotnet/coreclr#21652)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-23 19:07:03 +01:00
Jan Kotas da25533507 Delete CoreLib.FixupCoreLibName (dotnet/coreclr#21655)
This method doing blind find&replace of "mscorlib" with "System.Private.CoreLib". It is both incorrect (e.g. if the typename happened to contain "mscorlib" string) and inefficient (unnecessary allocations and use of reflection).

Signed-off-by: dotnet-bot <[email protected]>
2018-12-23 19:07:03 +01:00
Marek Safar 08ad82a826 Extracts public IThreadPoolWorkItem interface to shared CoreLib (#21653)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-23 11:08:56 +01:00
Marek Safar 676f268a9f Moves CoreLib to shared location (dotnet/coreclr#21654)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-23 11:06:13 +01:00
Ben Adams 55ca4eb088 SpanHelpers deal with nullable reference types (dotnet/coreclr#21232)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 21:37:34 +01:00
Jan Kotas 958529643c Move some Task related files to shared CoreLib partition (#21650)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 19:19:00 +01:00
Jan Kotas 6069e0909a Synchronize Task, Awaiter and ThreadPool implementation with CoreCLR (#6706)
Synchronized the code as much as possible with CoreCLR. The one major piece that I have excluded is tracing. I will look into doing that separately.

Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:29:22 +01:00
Jan Kotas edc045728c CoreRT-specific Object.cs changes - Fix build breaks - Apply same cleanup to all related files
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:29:22 +01:00
Jan Kotas d555d5ac7a Cleanup to match conventions
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:29:22 +01:00
Marek Safar ddb79c3924 Moves common part of Object to CoreLib shared
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:29:22 +01:00
Dan Moseley e1c1b7ad52 Remove _syncRoot field from collections (dotnet/coreclr#21628)
* SyncRoot

* Temp disable tests

* Disable outdated CoreFX test

* Tidier

Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:16:14 +01:00
Tanner Gooding fbfe1a8fc2 Ensure that the S.N.Vector methods are marked as [Intrinsic] and that the attribute is respected by the runtime (#21601)
* Updating the SIMD intrinsics to check for the `[Intrinsic]` attribute

* Ensure that the existing Vector/Vector<T> intrinsic methods are marked as such.

* Fixing Vector<T>.DotProduct and Vector.AndNot to be treated as intrinsic

* Fixing `SIMDIntrinsicBitwiseAndNot` to swap the operands for XARCH

Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:16:14 +01:00
Marek Safar 48fe8a78c3 Moves ByReference to shared CoreLib (dotnet/coreclr#21633)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:16:14 +01:00
Fei Peng 44af99b0ab Implement the remaining BMI1/2 intrinsic (dotnet/coreclr#21480)
* Add tests for BMI1/2 intrinsic

* Implement the remaining BMI1/2 intrinsic

* Fix emitDispIns for BMI instruction

Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:16:14 +01:00
Fei Peng e13e7eb7a5 Add AggressiveInlining for Vector<T>.op_Multiply (dotnet/coreclr#21587)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:16:14 +01:00
Thays Grazia e8c0ce7605 When going to https://jenkins.mono-project.com/job/test-mono-pull-request-arm64/8921/testReport/junit/(root)/DebuggerTests/StackTraceInNative/ for example, we have no idea why the underlying process has exited. To figure it out, we need to go to https://jenkins.mono-project.com/job/test-mono-pull-request-arm64/8921/parsed_console/log_content.html#WARNING1 and scroll back up to where the test was executed to find out the debuggee process crashed with an assertion. (#12172)
This was fixed by redirecting the StandardOutput and StandardError of the debuggee process in the Mono.Debugger.Soft test suite.
2018-12-21 22:36:05 -02:00
Jay Krell a0b5245c77 [Coop] Mostly convert 30+ JIT icalls (and embedding API). (#11941)
* [Coop] Mostly convert 30+ icalls used via register_icall.
And infrastructure to support that.
The infrastructure is not as ideal as it could be.
In future the C preprocessor wrappers should be marshal-ilgen wrappers,
so the handles are more efficiently created.

Some of the conversion is incomplete and just goes back to raw pointers,
but mostly it is good.

Some of the conversion is by replacing previously manual conversion
with more automatic conversion, but most of it is new.

* Replace `foo_raw` with `foo` and `foo` with `foo_impl` per https://github.com/mono/mono/pull/11941#discussion_r243436712.

* Replace gchandle with no_safepoints in mono_string_builder_to_utf16_impl.
https://github.com/mono/mono/pull/11941#discussion_r243438706
at least the one loop.

* Fix windows build: mono_string_to_utf8str vs. mono_string_to_utf8str_impl.

* Fix boehm ves_icall_string_alloc vs. ves_icall_string_alloc_raw.

* Reduce apparent or actual diff.

* Add link to GitHub issue.

* Fix merge.

* Reduce another apparent but probably not actual diff.

* FIXME missing error

* Reduce diff in comment.

* Reduce diff in comment.
2018-12-21 18:12:37 -05:00
Alexander Kyte c2438b7dc2 [crash] Support extra merp params 2018-12-21 13:30:33 -05:00
Alexander Köplinger c11a3cdd53 Bump bockbuild 2018-12-21 16:47:02 +01:00
Cody Russell 5d4f630037 Bump bockbuild for VSTS #737323 fix to GtkNSView. (#11972) 2018-12-21 16:26:13 +01:00
Manuel de la Pena 5ce08b8433 Minor style changes. 2018-12-21 13:12:53 +01:00
Manuel de la Pena 5c2267c5a7 Fix error while chaging the request :/ 2018-12-21 13:12:53 +01:00
Manuel de la Pena 2bb9a2b39a Small typo. 2018-12-21 13:12:53 +01:00
Manuel de la Pena 4194c31994 No need to close the obc, it can be reused. 2018-12-21 13:12:53 +01:00
Manuel de la Pena a35d921f81 [Network] Fix CVE 2018-8292 on Mac OS X.
This commit ensures that CVE 2018-8292 is fixed by not setting
auto-redirect in the first request done by CFNetwork. CFNetwork has the
same bug, but we can work around it by performing the first request,
checking the response and, if it is a rediret, follow it without the
Authorization headers.
2018-12-21 13:12:53 +01:00
Filip Navara c628f13279 System.Windows.Forms: Fix incorrect layout for table layout nested in flow layout
Fixes issue #8922. The flow layout code specifies `int.MaxValue` as width in `GetPreferredSize` call, which the table layout didn't handle properly and tried to use all the available space.

Relevant WinForms open source code that implements the same behavior:
https://github.com/dotnet/winforms/blob/master/src/System.Windows.Forms/src/System/Windows/Forms/Layout/FlowLayout.cs#L183-L188

https://github.com/dotnet/winforms/blob/master/src/System.Windows.Forms/src/System/Windows/Forms/Layout/TableLayout.cs#L700-L702
2018-12-21 11:58:52 +01:00
PaulBol 7331c5e1d7 [WinForms] Dispose tooltips (#12059)
I noticed that some controls do not dispose tooltips and timers. Depending on the underlying implementation these may use native resources. Therefore I'd suggest to dispose these with the parent control to not rely on the garbage collector to eventually release the resources.

Additionally, in the case of `ToolStrip.cs` `CloseToolTip` would first create the objects before turning them off.
2018-12-21 10:50:12 +01:00
Egor Bogatov 534c98c070 [NS2.1] More types and members (#11944)
* Add NS21 Events to EventListener

* NS21: System.Data.DbProviderFactories

* Add ISOWeek

* some Socket API, etc

* more ns21 members

* Add GC.GetAllocatedBytesForCurrentThread stub

* clean up in icall-def.h

* bump corert

* Bump API snapshot submodule

* [csproj] Update project files
2018-12-21 10:37:22 +01:00
Zoltan Varga 7846f99f35 [jit] Emit a OP_NOT_NULL in MONO_EMIT_NULL_CHECK. (#12078) 2018-12-20 23:57:51 -05:00
Jay Krell 0d6d334bcb [Coop] Convert ves_icall_System_Array_FastCopy. (#11983)
* [Coop] Port ves_icall_System_Array_FastCopy.
  Using MONO_ENTER_NO_SAFEPOINTS / MONO_EXIT_NO_SAFEPOINTS.
2018-12-20 14:15:39 -05:00
Jay Krell fead81a538 [Coop] Convert System.String icalls. (#11991)
* [Coop] Mostly convert System.String icalls. But do not pin due to perf/profiler.

* Use MONO_ENTER_NO_SAFEPOINTS / MONO_EXIT_NO_SAFEPOINTS

* Add FIXME to MONO_HANDLE_RAW (mono_ldstr_metadata_sig ()), looks like a reasonable place to temporarily suspend the coop conversion graph walk.

* Restore MonoObjectHandleOut to mono_handle_assign_raw (was mono_handle_assign).
2018-12-20 14:13:10 -05:00
Alexander Köplinger ddf6249c1d Update Helix SDK to latest version (#12156)
They added retry logic inside of the SDK to deal with some expected Helix API responses.
2018-12-20 19:46:22 +01:00
dotnet bot ccd7b52ca8 Add System.Private.CoreLib shared sources (#12162)
Taken from corefx commit 5956ad35864352b38c53aa8c2d1ce012c96b168d. Subsequent updates will happen via a mirroring bot.
2018-12-20 18:51:17 +01:00
Zoltan Varga 53f091ea4f [runtime] Avoid typedref returns from icalls, wasm doesn't support them. (#12142)
* [runtime] Convert TypedReference icalls to handles, return the result using an out argument since wasm doesn't support TypedReference returns from icalls.

* Bump corlib version.

* [runtime] Change ArgIterator icalls to return typedref results using an out argument since wasm doesn't support typedref returns from icalls.

* Use MONO_HANDLE_RAW () only at the end.
2018-12-20 10:25:47 -05:00
Alexander Köplinger 5855fcd47b Bump ms-test-suite (#12150)
Brings in disabling of the ThreadLocalTests.RunThreadLocalTest8_Values_NegativeCases test (https://github.com/xamarin/ms-test-suite/pull/3)
2018-12-20 15:21:25 +01:00
Marek Safar 729bd4e45d Bootstraps netcore build (#12120)
This does not build but puts placeholders for syncing in place
2018-12-20 14:19:15 +01:00
monojenkins d6a9dc0a50 [bcl] Update BCL Linked Size (#11996) 2018-12-20 13:56:52 +01:00
Bernhard Urban d5b777ea13 [sdks] Add a XCODE32_DIR make variable and use it to compile the 32 bit cross compilers. (#12055)
Forward port of #10139

Needed for arm64_32 (#11691): We still need to build AOT compilers that are 32bit, which is only possible with Xcode9. However, arm64_32 needs Xcode10.
2018-12-20 13:40:54 +01:00
Larry Ewing 671708c403 Skip TypedReferenceTest fixture for WASM as it causes a runtime abort (#12124)
The sdks/wasm run-all-corlib target currently aborts in the TypedReferenceTest fixture. Skip it in that case by adding it to the NotWasm category.
2018-12-20 13:22:31 +01:00
Larry Ewing 3d64ae0618 Allow urls with a blob scheme to pass validation in WASM (#12121)
Relax HttpMessageRequest url scheme validation for wasm so that urls with a blob scheme make it to the host backend. Fixes #11681

note: the browser tests fail when running chrome 71 in headless mode, they work in chrome 70 and 72
2018-12-20 13:14:39 +01:00
Jo Shields 6de9c370ec Bump to latest SQLite for Mac bundle (#12118)
* Bump to latest SQLite for Mac bundle

* Explicitly disable editline support.

SQLite assumes that if editline is enabled (the default), then NCurses was compiled with TermInfo support, which is not true on Mac
2018-12-20 12:24:47 +01:00
Jay Krell 89736b3659 Reduce extern "C", in non-public headers. 2018-12-20 02:24:51 -08:00
Zoltan Varga a46e3305c4 [wasm] Run patch with -N so it doesn't fail if called more than once. 2018-12-19 11:36:12 -05:00
guthubuser e77d5bafef Update Graphics to find err
ystem.Exception: Generic Error [GDI+ status: GenericError]
  at System.Drawing.GDIPlus.CheckStatus (System.Drawing.Status status) [0x00079] in <bb99ab19679c4cf79f4136bd0faf8b5e>:0 
  at System.Drawing.Graphics.FillRectangle (System.Drawing.Brush brush, System.Int32 x, System.Int32 y, System.Int32 width, System.Int32 height) [0x00025] in <bb99ab19679c4cf79f4136bd0faf8b5e>:0 
  at System.Drawing.Graphics.FillRectangle (System.Drawing.Brush brush, System.Drawing.Rectangle rect) [0x0002c] in <bb99ab19679c4cf79f4136bd0faf8b5e>:0 
  at (wrapper remoting-invoke-with-check) System.Drawing.Graphics.FillRectangle(System.Drawing.Brush,System.Drawing.Rectangle)
  at System.Windows.Forms.Control.PaintControlBackground (System.Windows.Forms.PaintEventArgs pevent) [0x002ff] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.Control.OnPaintBackground (System.Windows.Forms.PaintEventArgs pevent) [0x00000] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.Control.WmPaint (System.Windows.Forms.Message& m) [0x0005f] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.Control.WndProc (System.Windows.Forms.Message& m) [0x001a4] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.ScrollBar.WndProc (System.Windows.Forms.Message& m) [0x00000] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.Control+ControlWindowTarget.OnMessage (System.Windows.Forms.Message& m) [0x00000] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.Control+ControlNativeWindow.WndProc (System.Windows.Forms.Message& m) [0x0000b] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.NativeWindow.WndProc (System.IntPtr hWnd, System.Windows.Forms.Msg msg, System.IntPtr wParam, System.IntPtr lParam) [0x00085] in <69ecb40f27a1431a99620933ba9a8b39>:0
2018-12-19 10:33:31 -05:00
Ankit Jain 56581e9cc4 [MacSDK] Bump NuGet to 4.8.1 2018-12-19 14:03:23 +01:00
Alexander Kyte 713162263d [crash] Fix reported utf encoding (#12123) 2018-12-19 07:48:16 -05:00
Zoltan Varga 0af7408340 [wasm] Enable EMULATED_FUNCTION_POINTERS. (#12077)
* [wasm] Add the fix for https://github.com/kripken/emscripten/issues/7399 as a patch for emscripten.

* [wasm] Factor out some flags from the makefile targets.

* [wasm] Enable EMULATED_FUNCTION_POINTERS.
2018-12-18 17:00:44 -05:00
Zoltan Varga a92701bd18 [aot] Add MONO_PATCH_INFO_INTERRUPTION_REQUEST_FLAG to the preinited got slots. (#12075) 2018-12-18 16:50:51 -05:00
Jay Krell 399264331b Reduce but don't eliminate excess extern "C".
G_BEGIN_DECLS is almost never needed. Esp. around entire files.
It is for "the OS" and interoperation with some code that is still C, like profilers.

MONO_BEGIN_DECLS is often used in internal headers, in which case the same, but
not addressed here.

MONO_BEGIN_DECLS is often used in public headers, along with comprehensive
MONO_API, in which case it is redundant. This would be useful if/when mono
goes back to using .def files, which are a good idea for multiple reasons.
2018-12-18 16:03:04 -05:00
Jay Krell 2f0b4b8593 Remove ves_icall_System_Threading_Thread_current_lcid.
Probably unused since a0c6e79318 in 2004.
Certainly unused since cc9c53a109 in 2008.
Except for use by MERP, replace with its implementation -- MONO_LOCALE_INVARIANT.
2018-12-18 15:58:05 -05:00
Ankit Jain e70f02a4c2 Bump msbuild to track xplat-master 2018-12-18 16:28:45 +01:00
Zoltan Varga 475431927c [jit] Call mono_register_jit_icall_full () in more places so most jit icalls can be called directly during AOT. (#12076)
* [jit] Call mono_register_jit_icall_full () in more places so most jit icalls can be called directly during AOT.

* Fix a c++-ism.

* Fix a c++-ism.

* Fix a c++-ism.
2018-12-18 08:18:28 -05:00
Martin Baulig e72f0a8a03 [gensources]: Add platform/project logic to tests.
The gensources tool now supports platform/specific .sources for nunit and xunit tests.
2018-12-18 13:14:07 +01:00
Maxim Lipnin 787c851fa5 Fix IndexOutOfRangeException in MethodInfo.ReturnParameter.IsDefined(type) 2018-12-18 12:23:59 +01:00
Jay Krell ea12da137a Null terminate in mono_string_to_byvalstr like the comment says (#11985)
and like mono_string_to_byvalwstr does and like the code
makes room for.
2018-12-17 16:41:46 -05:00
Jay Krell 05049138ec Remove MONO_HANDLE_ARRAY_SETRAW. 2018-12-17 16:40:54 -05:00
Jay Krell 2b6373afeb [Coop] Convert System.Globalization.CompareInfo. (#12063)
This is a subset of https://github.com/mono/mono/pull/12023, maybe easier to review
in smaller pieces.

Alternatives:
 1. Move more to managed.
 2. Remove the feature.
2018-12-17 16:35:19 -05:00
Jay Krell f8dbcf5ac7 [Coop] Mark RegisterReportingForNativeLib_internal NOHANDLES(). 2018-12-17 16:29:47 -05:00
Jb Evain 2993fa3281 [Mono.Debugger.Soft] Fix reading custom attribute named arguments on old protocol versions 2018-12-17 12:47:14 +01:00
Zoltan Varga f2d43e98d7 [wasm] Pass the bindings assembly to the linker. (#12061) 2018-12-17 06:20:36 -05:00
Johan Lorensson d42d675b81 Windows x64 LLVM assert support + MSVC only for none cross compiler build. (#11946)
* Add support for LLVM asserts in internal LLVM build on Windows.

* Only build LLVM using MSVC if not cross compiling.

If not cross compiling, building runtime where host/target is Windows, only
build and use LLVM as part of msvc build (only supported configuration),
disabled on gcc build.

Enforce 64-bit LLVM support when building using Visual Studio solution file.

* Disable Windows LLVM Visual Studio build on unsupported configurations.

Automatically disable Windows LLVM build in Visual Studio. This enables
the option to configure using --enable-llvm but still build all runtime
configurations from within Visual Studio. A warning will be issued into
build logs when LLVM support is disabled for a specific build configuration.

* Fix so build-init always have cygconf.h available when needed.
2018-12-14 15:45:33 -05:00
Jay Krell 1503ca4952 Cache MonoMethod in ves_icall_System_Security_SecureString_EncryptInternal / ves_icall_System_Security_SecureString_DecryptInternal. 2018-12-14 15:22:22 -05:00
Zoltan Varga d8faa8e881 [llvmonly] Emit unbox trampolines as 2 tables instead of a lookup function, this takes less space that the switch statement (#12054)
in the lookup function.
2018-12-13 23:16:48 -05:00
Zoltan Varga 0212106d36 [wasm] Add more helper make targets. (#12052) 2018-12-13 22:52:58 -05:00
Egor Bogatov 622609d54b Get rid of Registry in XmlReader (#12008) 2018-12-13 16:20:46 -05:00
Alexander Kyte 9b81922a62 [runtime] Don't probe aot cache on android 2018-12-13 16:08:12 -05:00
Alexander Kyte a8d10611ac [runtime] Fix aot mode double init check 2018-12-13 15:09:58 -05:00
Alexander Kyte 799991bc34 [runtime] Don't assert when MONO_AOT_MODE_NONE passed to setter 2018-12-13 14:31:22 -05:00
Alexander Kyte cc7aefb008 [runtime] Don't probe for assemblies when MONO_AOT_MODE_NONE is set 2018-12-13 14:30:44 -05:00
Jay Krell 3fbafe6550 Fix MonoSortKey native/managed layout mismatch. (#12043)
Fix MonoSortKey native/managed layout mismatch.

MonoSortKey native:
https://github.com/mono/mono/blob/f019810b12ba130b7fed1cd41bb2eaed04ececef/mono/metadata/object-internals.h#L700

SortKey managed:
https://github.com/mono/mono/blob/f019810b12ba130b7fed1cd41bb2eaed04ececef/mcs/class/corlib/Mono.Globalization.Unicode/SortKey.cs#L69

do not agree.

Memory is corrupted and crash if you set $MONO_DISABLE_MANAGED_COLLATION=yes documented here:
https://github.com/mono/mono/blob/f019810b12ba130b7fed1cd41bb2eaed04ececef/man/mono.1#L1161

Fix is to remove the native code and replace by trivial managed.

Found testing coop-conversion of System.Globalization. https://github.com/mono/mono/pull/12023
2018-12-13 12:55:43 -05:00
Zoltan Varga 087b198c99 [wasm] Remove the old 32 cross compiler, its not used anymore. (#12046) 2018-12-13 12:09:30 -05:00
Thays Grazia 05188e03f9 [debugger] Fix test StepOutAsync (#12032)
* The problem with this flaky issue was the timing of processing of the async tasks, as it was executed in background threads it was not possible to reach the end of execution because all the foreground threads exit earlier.
The solution creates a TaskScheduler that ensure that the thread that will execute the task will be a foreground thread and then the test always works.

Fixes #6997
2018-12-13 11:50:06 -05:00
Calvin Buckley a3ef7c874e Update corefx submodule for AIX readdir_r fix (#12031)
Exposes a race condition in CoreFX when gensources tries to enumerate Cecil sources. Run it without `--trace=all`, 86 sources found. Run it with, even if redirected to `/dev/null`, 132 sources found. Eeeeeek.
2018-12-13 11:44:26 -05:00
Zoltan Varga 01f6a0203b [wasm] Avoid dedup-ing StructureToPtr/PtrToStructure wrappers, its not neccessary, and it doesn't seem to work. (#12033) 2018-12-13 10:06:34 -05:00
Jay Krell dfc517c346 [Coop] Mark 15 icalls as NOHANDLES. (#12028) 2018-12-13 09:47:49 -05:00
Kenneth Pouncey f019810b12 Merge pull request #11943 from kjpou1/wasm-test-suite
[wasm] Add browser test suite.
2018-12-13 09:13:45 -05:00
Alexander Kyte 118684e89b [runtime] Remove duplicate merp invoke line (#12036)
[runtime] Remove duplicate merp invoke line

Looks like this broke when it got squashed down, or we overlooked it. We've got two calls where we expected one.
2018-12-13 09:05:24 -05:00
Zoltan Varga 2e05d26cfa [jit] Add beginnings of llvmonly+interp mixed mode support. (#11987)
[jit] Add beginnings of llvmonly+interp mixed mode support.
2018-12-13 08:55:57 -05:00
Jay Krell 28b1e79d19 Fix two leaks in error paths. (#12042) 2018-12-13 05:17:54 -08:00
Jay Krell 5870948f56 Remove ves_icall_System_Globalization_CompareInfo_internal_index_char. (#12026)
Unused since Feb 2018 d63e8b6f5a.
2018-12-12 15:03:26 -08:00
Jay Krell 40d462b6ee Remove unused ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_lcid. (#12024)
Remove unused ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_lcid.

See 0204abe803 from 2009.
2018-12-12 17:25:40 -05:00
Jay Krell bdf4e262a0 Cleanup mono_ldstr_metadata_sig esp. remove extra mono_string_intern_checked. 2018-12-12 16:32:36 -05:00
Jay Krell 5e45fb2760 Set error in mono_string_new_utf8_len_handle, mono_string_new_len_checked. 2018-12-12 16:22:58 -05:00
Martin Baulig 41e57c671f [resx2sr]: Giving this tool some love. (#11969) 2018-12-12 09:34:54 -05:00
Jay Krell 22a4056ecf [Coop] Add typechecking to MONO_HANDLE_SETVAL and fix mistakes it finds. (#12021)
[Coop] Add typechecking to MONO_HANDLE_SETVAL and fix mistakes it finds.
2018-12-11 20:25:39 -05:00
Jay Krell 6265eb0223 Remove ERROR_DECL_VALUE. (#12012)
Remove ERROR_DECL_VALUE.
2018-12-11 14:35:43 -05:00
Calvin Buckley 0c30564bc9 for "build" config, import corlib common sources at unix instead (#11989)
...of importing it at linux/macOS

this unbreaks the build on "unix" platforms like FreeBSD and AIX

(is this all needed files, and am I doing this right?)
2018-12-10 15:01:04 -05:00
Jay Krell a91771787c [Coop] Mark System.ArgIterator all NOHANDLES. (#12003) 2018-12-10 11:39:18 -08:00
Jay Krell a29aa4ac80 Reduce lock hold times. (#11997) 2018-12-10 06:20:51 -08:00
Jay Krell de37ae3168 Inline mono_string_handle_length by making it a macro, usually. (#11994) 2018-12-10 04:04:33 -08:00
Jay Krell 3be2618c63 Quash warning icall.c:4408:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses] (#11993)
if (klass = m_class_get_parent (klass))
            ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
icall.c:4408:12: note: place parentheses around the assignment to silence this warning
        if (klass = m_class_get_parent (klass))
                  ^
            (                                 )
icall.c:4408:12: note: use '==' to turn this assignment into an equality comparison
        if (klass = m_class_get_parent (klass))
2018-12-10 01:04:54 -08:00
Jay Krell 52a07dd48e [Coop] Convert System.Security.SecureString. (#11995) 2018-12-09 23:46:20 -08:00
Alexander Köplinger 2f678add77 Bump corefx 2018-12-09 08:09:04 -05:00
Alexis Christoforides fd424c5dd0 [corlib] Import System.IO.TextWriter/StreamWriter from CoreFX (#11783)
* [corlib] Import System.IO.TextWriter/StreamWriter from CoreFX

* Adjust a Mono test. According to CoreFX TextWriter sources, CoreNewLine should only be used for read-only purposes.

* Bump CoreCLR for bug fix on test which becomes much flakier apparently with this patch

* Bump corefx

* Bump API snapshot submodule

* [csproj] Update project files
2018-12-09 08:05:45 -05:00
monojenkins 2cdcf190af [bcl] Update BCL Linked Size 2018-12-08 18:43:32 +01:00
Jay Krell ce1b1cd473 sizeof (gpointer) => sizeof (target_mgreg_t). (#11981) 2018-12-08 08:48:47 -08:00
Jay Krell cdf8c2923e [sgen] Make CHECK_CANARY_FOR_OBJECT a function. (#11971) 2018-12-08 02:47:37 -08:00
Jay Krell fd1458579f marshal.c cleanup (#11968)
- Reduce length computations of string builders.
 - Handle zero sized StringBuilder correctly (initialize the first
   not just the second character).
 - Check for overflow correctly in StringBuilder -- include offset.
 - Fix prototype of mono_string_to_byvalstr (gpointer vs. char*)
 - Fix prototype of mono_string_to_byvalwstr (gpionter vs. gunichar2*).
 - Single point of exit in mono_string_builder_to_utf8.
2018-12-08 02:05:19 -08:00
Kenneth Pouncey beb8397421 Address review comments 2018-12-07 15:55:23 +01:00
Larry Ewingandkjpou1 904e8d48ff Update sdks/wasm/tests/browser/http-spec.js
Update with review suggestion

Co-Authored-By: kjpou1 <[email protected]>
2018-12-07 15:38:42 +01:00
Larry Ewingandkjpou1 039044d320 Update sdks/wasm/tests/browser/http-spec.js
Update with review comment suggestion

Co-Authored-By: kjpou1 <[email protected]>
2018-12-07 15:38:16 +01:00
Alexis Christoforides 449e36638f [corlib] Import FileSystemInfo and family from CoreFX (#11342)
Includes the following from System.IO:

* FileSystemInfo
* FileInfo
* DirectoryInfo
* Directory
* FileSystem
* Path `Join()` Span API

and all of System.IO.Enumeration namespace.

Adds about 1600 System.IO tests

Behavior changes:
* `File.Replace` now replaces files even if they are read-only (using the `rename` syscall on Unix)
* Directory enumeration is no longer stable in the way that many Mono tests expect
* Some changes in when/whether some representations of directories contain a trailing separator character
* Changes in which exceptions are thrown (sometimes these are platform-dependent on CoreFX)

Issues:
* https://github.com/dotnet/corefx/issues/33486
* https://github.com/dotnet/corefx/issues/33490

Part of #7246
2018-12-07 15:02:23 +01:00
Jay Krell 3643f411a0 Fix cross compile of libtest. (#11865)
CC       libtest_la-libtest.lo
    <inline asm>:37:2: error: instruction requires: Not 64-bit mode
            popl %eax
            ^
    ... same error many times

Fix ThisCall tests.

Libtest.c needs to be C++ for Visual C+++ to accept __thiscall.
gcc accepts __thiscall in C.

Visual C++ only accepts __thiscall on member functions and function pointers,
not globals. Gcc accepts on globals also.
So test what we can.

add extern C

Limit thiscall testing to Win32, even if gcc has more support.
2018-12-06 10:49:33 -08:00
Jay Krell c80110cb05 [w32file-unix] Use mono_dl_open in place of dlopen
* Cleanup boehm/dlopen per https://github.com/mono/mono/pull/11853#discussion_r238861650.
https://github.com/mono/mono/issues/11936

* s/mono_dlopen/mono_dl_open s/dlsym/mono_dl_symbol

* s/dlclose/mono_dl_close

* Fix mono_dl_symbol use.

* Fix mono_dl_open call.

* Fix type of libc_handle for mono_dl vs. regular dl.
2018-12-06 13:48:20 -05:00
Jay Krell 943fa94bce Fix CHECK_CANARY_FOR_OBJECT. (#11957)
Fix CHECK_CANARY_FOR_OBJECT.

..\mono\metadata\sgen-mono.c(1443): warning C4390: ';': empty controlled statement found; is this the intent?

(Why is this not a function?)
2018-12-06 12:55:37 -05:00
Jay Krell eeb7e6bdb5 Remove mono_array_to_byvalarray and mono_byvalarray_to_array. (#11954)
Remove mono_array_to_byvalarray      and mono_byvalarray_to_array.

Only   mono_array_to_byte_byvalarray and mono_byvalarray_to_byte_array are used.
2018-12-06 11:55:51 -05:00
Alexander Köplinger ee3afd3103 [acceptance-tests] Add a generated file to .gitignore 2018-12-06 17:19:48 +01:00
Alexander Kyte e1461ebc85 [crash] Switch crash reporting writers to no-allocate + validate json (#11884)
* [crash] Switch merp dumper to no-allocate file writer

- Pass merp directory to backend (optional)
- Adds tests that needed the named change

* [crash] Make mono-state use non-allocating format strings

* [crash] Add json formatting validators to mono/tests

* [crash] Make crash-sending icalls use const strings

* [crash] Use fork+exec for merp

* [crash] Throw exception when unable to contact merp

* [crash] Disable merp-json-valid test on non-OSX
2018-12-06 10:57:05 -05:00
Jay Krell ff04de942b [cxx] Fix arm+arm64 since 9a9439329b. (#11958) 2018-12-06 15:56:32 +01:00
Jay Krell 13e9729ed6 Eliminate mgreg_t in favor of target_mgreg_t and host_mgreg_t. And one minor fix. (#11952)
* Elimination of mgreg_t in favor of target_mgreg_t and host_mgreg_t.

* [mips] Fix one host vs. target size.

* easier to read in narrow screen

* For posterity.
2018-12-06 08:23:39 -05:00
Alexander Köplinger e031ff4425 [ci] Replace plus with uri-encoded version in build url reported to Helix 2018-12-06 14:00:21 +01:00
Jo Shields 21dcc74a7a [Win32] Enable BTLS in Windows builds (#11947) 2018-12-06 12:59:09 +01:00
Jay Krell 8525f4c679 Fix race condition in mono_string_builder_new. (#11955)
Fix race condition in mono_string_builder_new.
2018-12-06 06:25:45 -05:00
Calvin Buckley bbb475d058 Fix regression with building PPC JIT (#11948)
* Fix regression with building PPC JIT

d5547b1929 made an incorrect change
to `mini-ppc.c` that wouldn't build; revert that file.

* Switch to fixing mini-ops.h instead
2018-12-06 10:41:39 +01:00
Egor Bogatov cd21cdb1b6 Display AM/PM for ko-KR culture (#11327)
Fixes https://github.com/mono/mono/issues/11317
(I guess I need to update culture-info-tables.h via make but it doesn't work on Windows, I have to switch to macOS).
2018-12-06 10:13:31 +01:00
Jay Krell 858434201d Fix cross compile of libtest.
CC       libtest_la-libtest.lo
    <inline asm>:37:2: error: instruction requires: Not 64-bit mode
            popl %eax
            ^
    ... same error many times

Fix ThisCall tests.

Libtest.c needs to be C++ for Visual C+++ to accept __thiscall.
gcc accepts __thiscall in C.

Visual C++ only accepts __thiscall on member functions and function pointers,
not globals. Gcc accepts on globals also.
So test what we can.

add extern C

Limit thiscall testing to Win32, even if gcc has more support.
2018-12-06 00:46:21 -08:00
Jay Krell 7f729566b4 Adjust test (not runtime) to workaround Windows i386 GCC ABI bug. 2018-12-06 00:11:13 -08:00
Jay Krell 71d46c815d Remove excess extern "C" per https://github.com/mono/mono/pull/11121#issuecomment-444562586. (#11950)
Remove one excess extern "C" per https://github.com/mono/mono/pull/11121#issuecomment-444562586.

There are many more.
2018-12-06 01:25:39 -05:00
Kenneth Pouncey bb6aae9a6e Small clean up to use path variable instead of relative path. 2018-12-06 05:15:12 +01:00
Jay Krell 9a9439329b Host/target corrections and clarifications and cleanup. (#11887) 2018-12-05 18:01:55 -08:00
Alexander Kyte c84ae2e7e9 [crash] Add crash reporter logger (#11855)
* [crash] Add crash reporter logger

* [crash] Disable mono-merp when disabling crash reporting
2018-12-05 17:19:34 -05:00
Jay Krell 4a5d19498b Move MONO_STRFTIME_T and MONO_STRFTIME_F to mono-time.h. 2018-12-05 16:50:29 -05:00
Jay Krell 66d1da652e strftime(%F) and strftime(%T) are non-portable shorthands that produce
a lot of warnings in the build. Expand them to their portable equivalents.
2018-12-05 16:50:29 -05:00
Zoltan Varga d5547b1929 [jit] Rename the textual names of several instructions so they match the opcode names. (#11938) 2018-12-05 16:05:39 -05:00
Jay Krell 460c8b4c16 Split mono_class_init into mono_class_init and mono_class_init_internal, add GC mode transition to first. (#11121)
mono_class_init_internal is what mono_class_init was.
mono_class_init *adds* missing GC mode transitions and calls mono_class_init_internal.

Replace mono_class_init with mono_class_init_internal.
2018-12-05 12:27:44 -08:00
Jay Krell 45407470db Quash some "may be used uninitialized" warnings.
/s/mono/mono/mini/interp/interp.c: In function 'interp_entry_from_trampoline':
/s/mono/mono/mini/interp/interp.c:2422:3: warning: 'orig_domain' may be used uninitialized in this function [-Wmaybe-uninitialized]
   mono_threads_detach_coop (orig_domain, &attach_cookie);
   ^
/s/mono/mono/mini/interp/interp.c: In function 'interp_exec_method_full':
/s/mono/mono/mini/interp/interp.c:2695:4: warning: 'locals' may be used uninitialized in this function [-Wmaybe-uninitialized]
    memset (locals, 0, rtm->locals_size);
    ^
/s/mono/mono/mini/method-to-ir.c: In function 'mini_handle_enum_has_flag':
/s/mono/mono/mini/method-to-ir.c:3416:9: warning: 'load' may be used uninitialized in this function [-Wmaybe-uninitialized]
    load = mono_decompose_opcode (cfg, load);
         ^
At least the first two seem to be compiler weakness.
2018-12-05 13:14:00 -05:00
Jay Krell 40f86511d4 Fix a bunch of warnings. (#11859)
* Fix a bunch of warnings.

/s/mono/mono/metadata/marshal.c:4862:72: warning: format specifies type 'unsigned long' but the argument has type 'gsize' (aka 'unsigned int') [-Wformat]
                mono_error_set_out_of_memory (error, "Could not allocate %lu bytes", size);
                                                                         ~~~         ^~~~
                                                                         %zu
/s/mono/mono/metadata/marshal.c:6229:1: warning: unused function 'install_noilgen' [-Wunused-function]
install_noilgen (void)
^
                                                        %llx

/s/mono/mono/metadata/w32file-unix.c:4877:147: warning: format specifies type 'void *' but the argument has type 'gint' (aka 'int') [-Wformat]
        mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER_FILE, "%s: Unlocking fd %p, offset %" G_GINT64_FORMAT ", length %" G_GINT64_FORMAT, __func__, ((MonoFDHandle*) filehandle)->fd, (gint64) offset, (gint64) length);
                                                                                   ~~                                                                    ^~

/s/mono/mono/metadata/w32process-unix-internals.h:44:1: warning: unused function 'mono_w32process_module_free' [-Wunused-function]
mono_w32process_module_free (MonoW32ProcessModule *module)
^

/s/mono/mono/utils/mono-threads-android.c:44:1: warning: no previous prototype for function 'mono_threads_platform_get_stack_bounds' [-Wmissing-prototypes]
mono_threads_platform_get_stack_bounds (guint8 **staddr, size_t *stsize)
^

/s/mono/mono/mini/interp/transform.c:1666:15: warning: unused variable 'vt' [-Wunused-variable]
                MonoVTable *vt = mono_class_vtable_checked (domain, target_method->klass, error);
                            ^
/s/mono/mono/utils/mono-counters.c:547:55: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'gssize' (aka 'int') [-Wformat]
                fprintf (outfile, ENTRY_FMT "%zd\n", counter->name, *(gssize*)buffer);
                                             ~~~                    ^~~~~~~~~~~~~~~~
                                             %td

/s/mono/mono/sgen/sgen-debug.c:1066:72: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'int' [-Wformat]
        fprintf (heap_dump_file, "<occupied offset=\"%zd\" size=\"%zd\"/>\n", start - section_start, end - start);
                                                     ~~~                      ^~~~~~~~~~~~~~~~~~~~~
                                                     %d
/s/mono/mono/sgen/sgen-debug.c:1066:95: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'int' [-Wformat]
        fprintf (heap_dump_file, "<occupied offset=\"%zd\" size=\"%zd\"/>\n", start - section_start, end - start);
                                                                  ~~~                                ^~~~~~~~~~~
                                                                  %d
/s/mono/mono/sgen/sgen-debug.c:1139:4: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword' (aka 'unsigned int') [-Wformat]
                        safe_object_get_size (obj));
                        ^~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-debug.c:37:30: note: expanded from macro 'safe_object_get_size'
                                ^
/s/mono/mono/sgen/sgen-memory-governor.c:309:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->promoted_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~

/s/mono/mono/sgen/sgen-debug.c:1139:4: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword' (aka 'unsigned long long') [-Wformat]
                        safe_object_get_size (obj));
                        ^~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-debug.c:37:30: note: expanded from macro 'safe_object_get_size'
                                ^
/s/mono/mono/metadata/w32file-unix.c:70:9: warning: 'INVALID_HANDLE_VALUE' macro redefined [-Wmacro-redefined]
        ^
/s/mono/mono/metadata/w32handle.h:19:9: note: previous definition is here
        ^
/s/mono/mono/metadata/handle.c:159:31: warning: 'extern' variable has an initializer [-Wextern-initializer]
extern MonoThreadInfo * const mono_thread_info_current_var = NULL;
                              ^
/s/mono/mono/mini/branch-opts.c:117:18: warning: unused variable 'int_cmov_opcodes' [-Wunused-const-variable]
static const int int_cmov_opcodes [] = {
                 ^
/s/mono/mono/mini/branch-opts.c:130:18: warning: unused variable 'long_cmov_opcodes' [-Wunused-const-variable]
static const int long_cmov_opcodes [] = {
                 ^
/s/mono/mono/mini/interp/interp.c:1233:1: warning: unused label 'exit_pinvoke' [-Wunused-label]
exit_pinvoke:
^~~~~~~~~~~~~
/s/mono/mono/mini/interp/interp.c:1900:1: warning: unused label 'exit_icall' [-Wunused-label]
exit_icall:
^~~~~~~~~~~

/s/mono/mono/mini/interp/transform.c:1668:7: warning: unused variable 'called_inited' [-Wunused-variable]
                int called_inited = vt->initialized;
                    ^
                                 ^/s/mono/mono/sgen/sgen-debug.c:1139:4: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword' (aka 'unsigned long long')
      [-Wformat]
                        safe_object_get_size (obj));
                        ^~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-debug.c:37:30: note: expanded from macro 'safe_object_get_size'
                                ^
/s/mono/mono/sgen/sgen-descriptor.c:132:52: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Ptrfree descriptor %p, size: %zd", (void*)desc, stored_size);
                                                                 ^
/s/mono/mono/sgen/sgen-descriptor.c:145:70: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Largebitmap descriptor %p, size: %zd, last set: %d", (void*)desc, stored_size, last_set);
                                                                                   ^
/s/mono/mono/sgen/sgen-descriptor.c:156:80: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                        SGEN_LOG (6, "Runlen descriptor %p, size: %zd, first set: %d, num set: %d", (void*)desc, stored_size, first_set, num_set);
                                                                                                    ^
/s/mono/mono/sgen/sgen-gc.c:1252:82: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int') [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
                                                                                               ^
/s/mono/mono/sgen/sgen-nursery-allocator.c:800:114: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword'
      (aka 'unsigned long long') [-Wformat]
  ...SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", p, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (p)), sgen_safe_object_get_size (p));
                                                      ~~~                                                          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                                      %llu
/s/mono/mono/sgen/sgen-gc.h:143:69: note: expanded from macro 'SGEN_LOG'
                mono_gc_printf (sgen_gc_debug_file, "%s " format "\n", logTime, ##__VA_ARGS__); \
                                                                                  ^~~~~~~~~~~
/s/mono/mono/utils/mono-logger-internals.h:109:34: note: expanded from macro 'mono_gc_printf'
        fprintf (gc_log_file, format, ##__VA_ARGS__);   \
                                        ^~~~~~~~~~~
/s/mono/mono/sgen/sgen-pinning.c:213:117: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword'
      (aka 'unsigned long long') [-Wformat]
  ...SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", ptr, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (ptr)), sgen_safe_object_get_size (ptr));
                                                      ~~~                                                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                                      %llu
/s/mono/mono/sgen/sgen-gc.h:143:69: note: expanded from macro 'SGEN_LOG'
                mono_gc_printf (sgen_gc_debug_file, "%s " format "\n", logTime, ##__VA_ARGS__); \
                                                                                  ^~~~~~~~~~~
/s/mono/mono/utils/mono-logger-internals.h:109:34: note: expanded from macro 'mono_gc_printf'
        fprintf (gc_log_file, format, ##__VA_ARGS__);   \
                                        ^~~~~~~~~~~
/s/mono/mono/metadata/w32file-unix.c:70:9: warning: 'INVALID_HANDLE_VALUE' macro redefined [-Wmacro-redefined]
        ^
/s/mono/mono/metadata/w32handle.h:19:9: note: previous definition is here
        ^
/s/mono/mono/metadata/handle.c:159:31: warning: 'extern' variable has an initializer [-Wextern-initializer]
extern MonoThreadInfo * const mono_thread_info_current_var = NULL;
                              ^
/s/mono/mono/metadata/sgen-mono.c:107:95: warning: cast to 'gpointer' (aka 'void *') from smaller integer type 'MonoGCDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
        SGEN_LOG (8, "Adding value remset at %p, count %d, descr %p for class %s (%p)", dest, count, (gpointer)m_class_get_gc_descr (klass), m_clas...
                                                                                                     ^
/s/mono/mono/metadata/sgen-mono.c:1741:83: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Profiler root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
                                                                                                ^
/s/mono/mono/mini/helpers.c:72:9: warning: 'ARCH_PREFIX' macro redefined [-Wmacro-redefined]
        ^
/s/mono/mono/mini/helpers.c:68:9: note: previous definition is here
        ^
/s/mono/mono/mini/branch-opts.c:117:18: warning: unused variable 'int_cmov_opcodes' [-Wunused-const-variable]
static const int int_cmov_opcodes [] = {
                 ^
/s/mono/mono/mini/branch-opts.c:130:18: warning: unused variable 'long_cmov_opcodes' [-Wunused-const-variable]
static const int long_cmov_opcodes [] = {
                 ^
/s/mono/mono/mini/mini-arm.c:7363:1: warning: no previous prototype for function 'mono_arch_get_seq_point_info' [-Wmissing-prototypes]
mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code)
^
/s/mono/mono/mini/exceptions-arm.c:241:65: warning: implicit conversion from 'unsigned long' to 'int' changes value from 18446744073709551612 to -4
      [-Wconstant-conversion]
        mono_add_unwind_op_offset (unwind_ops, code, start, ARMREG_LR, - sizeof (mgreg_t));
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~
/s/mono/mono/mini/mini-unwind.h:132:170: note: expanded from macro 'mono_add_unwind_op_offset'
  ...do { (op_list) = g_slist_append ((op_list), mono_create_unwind_op ((code) - (buf), DW_CFA_offset, (reg), (offset))); } while (0)
                                                 ~~~~~~~~~~~~~~~~~~~~~                                         ^~~~~~
/s/mono/mono/mini/interp/interp.c:1233:1: warning: unused label 'exit_pinvoke' [-Wunused-label]
exit_pinvoke:
^~~~~~~~~~~~~
/s/mono/mono/mini/interp/interp.c:1900:1: warning: unused label 'exit_icall' [-Wunused-label]
exit_icall:
^~~~~~~~~~~
/s/mono/mono/mini/interp/transform.c:1668:7: warning: unused variable 'called_inited' [-Wunused-variable]
                int called_inited = vt->initialized;
                    ^

/s/mono/mono/utils/mono-time.c:23:34: warning: unused variable 's_TimebaseInfo' [-Wunused-variable]
static mach_timebase_info_data_t s_TimebaseInfo;
                                 ^
/s/mono/mono/sgen/sgen-debug.c:1139:4: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword' (aka 'unsigned long long')
      [-Wformat]
                        safe_object_get_size (obj));
                        ^~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-debug.c:37:30: note: expanded from macro 'safe_object_get_size'
                                ^
/s/mono/mono/sgen/sgen-descriptor.c:132:52: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Ptrfree descriptor %p, size: %zd", (void*)desc, stored_size);
                                                                 ^
/s/mono/mono/sgen/sgen-descriptor.c:145:70: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Largebitmap descriptor %p, size: %zd, last set: %d", (void*)desc, stored_size, last_set);
                                                                                   ^
/s/mono/mono/sgen/sgen-descriptor.c:156:80: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                        SGEN_LOG (6, "Runlen descriptor %p, size: %zd, first set: %d, num set: %d", (void*)desc, stored_size, first_set, num_set);
                                                                                                    ^
/s/mono/mono/sgen/sgen-gc.c:1252:82: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int') [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
                                                                                               ^
/s/mono/mono/sgen/sgen-nursery-allocator.c:800:114: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword'
      (aka 'unsigned long long') [-Wformat]
  ...SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", p, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (p)), sgen_safe_object_get_size (p));
                                                      ~~~                                                          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                                      %llu
/s/mono/mono/sgen/sgen-gc.h:143:69: note: expanded from macro 'SGEN_LOG'
                mono_gc_printf (sgen_gc_debug_file, "%s " format "\n", logTime, ##__VA_ARGS__); \
                                                                                  ^~~~~~~~~~~
/s/mono/mono/utils/mono-logger-internals.h:109:34: note: expanded from macro 'mono_gc_printf'
        fprintf (gc_log_file, format, ##__VA_ARGS__);   \
                                        ^~~~~~~~~~~

/s/mono/mono/sgen/sgen-pinning.c:213:117: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword'
      (aka 'unsigned long long') [-Wformat]
  ...SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", ptr, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (ptr)), sgen_safe_object_get_size (ptr));
                                                      ~~~                                                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                                      %llu
/s/mono/mono/sgen/sgen-gc.h:143:69: note: expanded from macro 'SGEN_LOG'
                mono_gc_printf (sgen_gc_debug_file, "%s " format "\n", logTime, ##__VA_ARGS__); \
                                                                                  ^~~~~~~~~~~
/s/mono/mono/utils/mono-logger-internals.h:109:34: note: expanded from macro 'mono_gc_printf'
        fprintf (gc_log_file, format, ##__VA_ARGS__);   \
                                        ^~~~~~~~~~~

/s/mono/mono/metadata/w32file-unix.c:70:9: warning: 'INVALID_HANDLE_VALUE' macro redefined [-Wmacro-redefined]
        ^
/s/mono/mono/metadata/w32handle.h:19:9: note: previous definition is here
        ^

/s/mono/mono/metadata/handle.c:159:31: warning: 'extern' variable has an initializer [-Wextern-initializer]
extern MonoThreadInfo * const mono_thread_info_current_var = NULL;
                              ^
/s/mono/mono/metadata/sgen-mono.c:107:95: warning: cast to 'gpointer' (aka 'void *') from smaller integer type 'MonoGCDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
        SGEN_LOG (8, "Adding value remset at %p, count %d, descr %p for class %s (%p)", dest, count, (gpointer)m_class_get_gc_descr (klass), m_clas...
                                                                                                     ^
/s/mono/mono/metadata/sgen-mono.c:1741:83: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Profiler root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);

* PR: Remove comments.

* Preserve unsignedness of GC descriptor in logging.
2018-12-05 08:22:59 -08:00
Calvin Buckley 4af055c794 Fix PowerPC regression caused by tracing changes (#11907)
2b029b3df4 broke ppc JIT tracing by
moving it into mini and changing the arguments. Since the mini IR
emitter handles tracing now, rip out the tracing code from the JIT.

(Looks like SPARC will need a similar change, but someone needs to
love SPARC first.)
2018-12-05 15:48:35 +01:00
Kenneth Pouncey 6f5204f5f1 Remove errant binary. 2018-12-05 14:12:47 +01:00
Kenneth Pouncey 23e5688caf [wasm] Add browser test suite.
The existing tests work with JavaScript Engines and do not have any way to test code that works only in the browser.   The JavaScript Engines do not have access to any browser API’s so functionality like the WasmHttpMessageHandler can not be tested.

- Add test suite that uses Headless Chrome and Node.js with Karma.
- Allows testing the browser API.
2018-12-05 13:52:00 +01:00
Jay Krell d62f73a79d Fix warnings and race condition in time keeping. (#11862)
* Fix warnings and race condition in time keeping.

/s/mono/mono/utils/mono-time.c:23:34: warning: unused variable 's_TimebaseInfo' [-Wunused-variable]
static mach_timebase_info_data_t s_TimebaseInfo;

/s/mono/mono/utils/mono-time.c:112:1: warning: unused function 'get_boot_time' [-Wunused-function]

* Remove boot_time, unused since https://github.com/mono/mono/commit/06a4273d73cfa732d911bdaf50f752c025a0665c.
2018-12-04 22:43:41 -08:00
Jay Krell bd96170808 Fix always-true assertion. (#11863)
Alternatively, safer, since it never worked, remove it.

   /s/mono/mono/utils/mono-error.c:124:28: warning: comparison of constant 'MONO_ERROR_CLEANUP_CALLED_SENTINEL' (65535) with expression of type 'short' is always true [-Wtautological-constant-out-of-range-compare]
            g_assert (orig_error_code != MONO_ERROR_CLEANUP_CALLED_SENTINEL);
                      ~~~~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Fixing this reveals problems in ves_icall_System_Threading_Thread_GetAbortExceptionState,
i.e. the repaired assert fails, so this depends on https://github.com/mono/mono/pull/11889.

Also cleanup and optimize nearby.
2018-12-04 18:24:22 -08:00
Jay Krell ad6de27b90 Fix more warnings. (#11853)
This isn't correct for Win64 but that should be ok.
It is correct for all other platforms.

/s/mono/mono/sgen/sgen-memory-governor.c:309:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->promoted_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:310:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->major_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:311:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->major_size_in_use / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:312:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:313:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size_in_use / 1024);
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:321:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:322:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size_in_use / 1024);
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:332:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:333:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size_in_use / 1024);
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:337:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->major_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:338:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->major_size_in_use / 1024);
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/s/mono/mono/metadata/w32file-unix.c:4688:1: warning: no previous prototype for function 'ves_icall_System_IO_DriveInfo_GetDriveType' [-Wmissing-prototypes]
ves_icall_System_IO_DriveInfo_GetDriveType (const gunichar2 *root_path_name, gint32 root_path_name_length, MonoError *error)
^

/s/mono/mono/metadata/remoting.c:2143:1: warning: no previous prototype for function 'mono_context_set_icall' [-Wmissing-prototypes]
mono_context_set_icall (MonoAppContext *new_context_raw)
^

/s/mono/mono/mini/mini-posix.c:229:2: warning: unused variable 'ctx' [-Wunused-variable]
        MONO_SIG_HANDLER_GET_CONTEXT;

And beware icall-decl.h + Boehm producing:
w32file-unix.c:4905:16: error: implicit declaration of function 'GC_dlopen' is invalid in C99 [-Werror,-Wimplicit-function-declaration]
        libc_handle = dlopen ("/usr/lib/libc.dylib", 0);
                      ^
or, if you fix that, unreferenced symbol _GC_dlopen.
2018-12-04 16:18:02 -08:00
Jay Krell dd58c519e4 Fix warnings and a C++ error.
mono/master 32beba680e with no local edits

The C++ compilation was likely an accident and I'll try again after git clean.

jaymac1:mono jay$ cat sdks/Mak*g
ENABLE_CXX=1

will run again with git clean.

 make -C sdks/builds build-ios-cross32 build-android-cross-arm build-android-cross-x86

/s/mono/mono/mini/mini-llvm.c:7729:18: warning: unused variable 'iter' [-Wunused-variable]
                GHashTableIter iter;
                               ^
/s/mono/mono/mini/mini-llvm.c:7730:15: warning: unused variable 'method' [-Wunused-variable]
                MonoMethod *method;
                            ^
/s/mono/mono/mini/mini-llvm.c:7731:11: warning: unused variable 'callers' [-Wunused-variable]
                GSList *callers, *l, *l2;
                        ^
/s/mono/mono/mini/mini-llvm.c:7731:21: warning: unused variable 'l' [-Wunused-variable]
                GSList *callers, *l, *l2;
                                  ^
/s/mono/mono/mini/mini-llvm.c:7731:25: warning: unused variable 'l2' [-Wunused-variable]
                GSList *callers, *l, *l2;
                                      ^
/s/mono/mono/mini/mini-llvm.c:9022:13: error: cannot initialize a variable of type 'CallSite *' with an lvalue of type 'gpointer' (aka 'void *')
                CallSite *site = g_ptr_array_index (module->callsite_list, sindex);
                          ^      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/s/mono/mono/mini/mini-llvm.c:9002:17: warning: unused variable 'iter' [-Wunused-variable]
        GHashTableIter iter;
                       ^
/s/mono/mono/mini/mini-llvm.c:9004:10: warning: unused variable 'callers' [-Wunused-variable]
        GSList *callers, *l;
                ^
/s/mono/mono/mini/mini-llvm.c:9004:20: warning: unused variable 'l' [-Wunused-variable]
        GSList *callers, *l;
2018-12-04 17:09:10 -05:00
Alexander Köplinger feb342ae4f Add PathHelpers.cs to EXTRA_DIST to fix tarball build 2018-12-04 22:28:18 +01:00
Alexander Kyte 436a44a764 Merge pull request #11636 from alexanderkyte/crash_reporter_no_timeout
[crash] Force lldb/gdb traces to appear during hangs
2018-12-04 14:12:24 -05:00
Alexander Kyte 9994a181fd [crash] Early exit if callbacks not set (#11909) 2018-12-04 13:40:00 -05:00
Jay Krell eca15996c7 Remove extra percent from GSIZE_FORMAT.
Every user puts one on and the result does not work.
2018-12-04 11:03:20 -05:00
Marek Safar fa06ac818c [corlib] Make by-ref struct actually ref now C# supports them. (#11871)
* [corlib] Make by-ref struct actually ref now C# supports them.

This is technically breaking change but the types are already specialized
in C# compiler to be ref structs therefore the breaking change is more
theoretical than practical

* [mcs] Improves error reporting for special runtime types

* Bump API snapshot submodule
2018-12-04 16:53:08 +01:00
Rolf Bjarne Kvinge 632bb59b21 [System] Implement a helper function to create unique temporary directories and use it in tests. (#11831)
While working on PR #11829 I stress-tested the tests by running multiple test
runs in parallel, and it turned out that many tests were not parallel-safe,
because they used the same temporary file names and ended up stomping on
eachother.

So I implemented a helper method that creates a guaranteed unique temporary
directory, and I've changed all tests to use this new helper method.
2018-12-04 16:43:23 +01:00
Neale Ferguson 18fdc10cc1 Fix order of parameter processing. Note the offsets appear different to the size of the variables being passed but s390x will align parameters on 64-bit boundaries which is why the gbooleans appear to be treated as gulongs. (#11912)
Fix order of parameter processing. 

New parameter addition was put in wrong spot in the parameter list. Also the offsets on the stack were incorrect as 32-bit values are placed in 64-bit aligned slots on s390x. Therefore, even though these are gbooleans the appear to be treated as gulongs.



<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2018-12-04 10:15:57 -05:00
Bernhard Urban 2f17f4f2a2 [bcl] add fullaotinterp_llvm preset (#11847)
* [bcl] add fullaotinterp_llvm preset

That is, the AOT compiler uses the LLVM backend for BCL. AOT+LLVM is
used in the 'Release' configuration on Xamarin.iOS.

* [aot_full_interp_llvm] enable corlib tests
2018-12-04 09:56:36 -05:00
Kenneth Pouncey 8c32d109a0 [ci] Re-Enable V8 tests on wasm (#11929)
-  Found latest V8 version: v7.3.16.  Works

Resolves: https://github.com/mono/mono/issues/11908
2018-12-04 15:54:56 +01:00
Jay Krell ac688eaa5d Fix and cleanup ves_icall_System_Threading_Thread_GetAbortExceptionState.
In particular, to not fail asserts related to MONO_ERROR_CLEANUP_CALLED_SENTINEL,
which are currently missing or incorrect.
2018-12-04 09:54:42 -05:00
monojenkins cf7b6cfd5f [csproj] Update project files 2018-12-04 11:13:19 +01:00
Jb Evain 83d63bf181 [Mono.Debugger.Soft] Make exposing Cecil metadata an option 2018-12-04 11:13:19 +01:00
Jay Krell 88a1ffcf0d More mgreg_t to host_mgreg_t or target_mgreg_t conversion. (#11914)
* More mgreg_t to host_mgreg_t or target_mgreg_t conversion.
 Mostly target_mgreg_t.
Note that this is all optional, in the sense that cross compilers
never run their runtime. So mgreg_t is always target_mgreg_t, or
they are the same.
But agreement is to ban mgreg_t.
2018-12-03 23:40:05 -08:00
Zoltan Varga f24d652d56 [wasm] AOT work. (#11826)
* [bcl] Disable some tests under WASM.

* [bcl] Pass a stack mark through TypeSpec.Resolve ().

* [runtime] Avoid freeing an error which gets passed back from an icall.

* [wasm] Make Environment.GetCommandLineArgs () work. Allow excluding tests on the command line.

* Fix some stackframe tests.

* [wasm] Add a missing dependency to the ninja files.
2018-12-03 20:41:28 -05:00
Mikhail Pilin 2be08fc551 Fix race condition in XmlCharType.Instance (#11814) 2018-12-03 19:18:46 -05:00
Jay Krell 03f5674a36 Fix compilation errors targeting 32bit from 64bit host. (#11861) 2018-12-03 15:47:50 -08:00
Alexander Kyte 8ea3be0255 [runtime] Add waitpid to probed-for libc functions 2018-12-03 17:13:16 -05:00
Alexander Kyte 82e6bda20a [crash] Create supervisor thread for crash dumper 2018-12-03 17:13:16 -05:00
Alexander Kyte f2d5baf6cb [runtime] Make sure lldb/gdb dump happens when MERP fails 2018-12-03 17:13:16 -05:00
Jo Shields f885880f31 Bump version to 5.23 (#11911) 2018-12-03 22:26:36 +01:00
4433 changed files with 447688 additions and 153422 deletions

No files matched your search

+4 -4
View File
@@ -13,11 +13,11 @@ mkinstalldirs crlf=input
*.h crlf
*.cs crlf
*.il crlf
*.sln crlf
*.*proj* crlf
# don't do anything to line-endings. Let CRLFs go into the repo, and CRLF on checkout
*.bat -crlf
*.sln -crlf
*.*proj* -crlf
# don't do anything to line-endings. Let CRLFs/LFs go into the repo, and CRLF/LFs on checkout
*.bat -crlf
*.xml -crlf
# CRLF Handling
+54 -54
View File
@@ -10,18 +10,18 @@
# These owners will be the default owners for everything in the repo.
* @luhenry @marek-safar
* @marek-safar
# Order is important. The last matching pattern has the most precedence.
/acceptance-tests @akoeplinger @kg
/acceptance-tests/profiler-stress* @alexrp @akoeplinger
/data @marek-safar @akoeplinger @luhenry
/data/gdb @vargaz @luhenry
/data @directhex @akoeplinger
/data/gdb @lewurm @vargaz
/data/lldb @lewurm @vargaz
/docs @luhenry @marek-safar @akoeplinger
/docs @marek-safar @akoeplinger
/docs/riscv.md @alexrp @lewurm
/docs/sources/mono-api-profiler.html @alexrp
@@ -34,18 +34,18 @@
/external/corefx @akoeplinger @marek-safar @egorbo @alexischr
/external/corert @akoeplinger @marek-safar @egorbo @alexischr
/external/linker @marek-safar
/external/llvm @luhenry @vargaz
/external/llvm @alexanderkyte @vargaz
/external/nuget-buildtasks @radical @akoeplinger
/external/roslyn-binaries @kg @marek-safar @akoeplinger
/libgc @BrzVlad @vargaz @luhenry
/libgc @BrzVlad @vargaz
/llvm @vargaz @luhenry
/llvm @vargaz @alexanderkyte
/man @marek-safar @miguel @luhenry
/man @marek-safar @miguel
/man/*prof* @alexrp
/mcs @marek-safar @luhenry
/mcs @marek-safar @akoeplinger @egorbo
/mcs/build @marek-safar @akoeplinger
@@ -54,9 +54,9 @@
/mcs/class/corlib/System.Security.Cryptography.X509Certificates @baulig @marek-safar
/mcs/class/Mono.Btls.Interface @bauligg @marek-safar
/mcs/class/Mono.Data.Tds @egorbo
/mcs/class/Mono.Debugger.Soft @vargaz
/mcs/class/Mono.Debugger.Soft @vargaz @thaystg
/mcs/class/Mono.Options @jonpryor @marek-safar
/mcs/class/Mono.Profiler.Log @alexrp @luhenry
/mcs/class/Mono.Profiler.Log @lambdageek
/mcs/class/Mono.Security/Mono.Security/Interface @baulig @marek-safar
/mcs/class/System/Mono.AppleTls @baulig @rolf
/mcs/class/System/Mono.Btls @baulig @marek-safar
@@ -73,80 +73,80 @@
/mcs/tools @marek-safar @akoeplinger
/mcs/tools/gensources @kg @akoeplinger
/mcs/tools/resx2sr @baulig
/mcs/tools/upload-to-sentry @alexanderkyte @akoeplinger
/mono/arch @vargaz @lewurm
/mono/btls @baulig @luhenry @marek-safar
/mono/btls @baulig @marek-safar
/mono/dis @lambdageek @vargaz
/mono/eglib @vargaz @luhenry
/mono/eglib @vargaz @lambdageek
/mono/benchmark @alexanderkyte @luhenry
/mono/benchmark @alexanderkyte @lewurm
/mono/metadata @vargaz @lambdageek
/mono/metadata/*verify* @lambdageek @luhenry
/mono/metadata/*profiler* @alexrp @luhenry
/mono/metadata/handle* @jaykrell @lambdageek
/mono/metadata @vargaz @lambdageek @thaystg
/mono/metadata/*profiler* @lambdageek
/mono/metadata/handle* @lambdageek @vargaz
/mono/metadata/monitor* @brzvlad @vargaz
/mono/metadata/sgen* @brzvlad @vargaz
/mono/metadata/thread* @luhenry @lateralusX
/mono/metadata/w32* @luhenry @lateralusX @jaykrell
/mono/metadata/*-win* @lateralusX @luhenry @luhenry
/mono/metadata/thread* @lateralusX @lambdageek
/mono/metadata/w32* @lateralusX @lambdageek
/mono/metadata/*-win* @lateralusX @lambdageek
/mono/mini @vargaz @lewurm
/mono/mini/*cfgdump* @lewurm @luhenry
/mono/mini/*exceptions* @lewurm @luhenry
/mono/mini @vargaz @lewurm @lambdageek
/mono/mini/*cfgdump* @lewurm @vargaz
/mono/mini/*exceptions* @lewurm @vargaz
/mono/mini/*ppc* @lewurm @vargaz
/mono/mini/*riscv* @alexrp @lewurm
/mono/mini/*type-check* @lewurm @lambdageek
/mono/mini/interp/* @lewurm @BrzVlad
/mono/mini/*profiler* @alexrp @luhenry
/mono/mini/debugger-agent.c @vargaz @lewurm @DavidKarlas
/mono/mini/*profiler* @alexrp @lambdageek
/mono/mini/debugger-agent.c @vargaz @thaystg @DavidKarlas
/mono/native @baulig @luhenry @marek-safar
/mono/native @baulig @egorbo @alexischr @marek-safar
/mono/profiler @alexrp @luhenry
/mono/profiler @alexrp @lambdageek
/mono/sgen @BrzVlad @luhenry
/mono/sgen @BrzVlad @lambdageek
/mono/utils @vargaz @lewurm
/mono/utils/atomic* @lewurm @luhenry
/mono/utils/mono-hwcap* @lewurm @luhenry
/mono/utils/mono-mem* @lewurm @luhenry
/mono/utils/mono-threads* @luhenry @vargaz
/mono/utils/*-win* @lateralusX @jay
/mono/utils @vargaz @lewurm @lambdageek
/mono/utils/atomic* @lewurm @vargaz
/mono/utils/mono-hwcap* @lewurm @vargaz
/mono/utils/mono-mem* @lewurm @vargaz
/mono/utils/mono-threads* @lambdageek @vargaz
/mono/utils/*-win* @lateralusX @lambdageek
/msvc @lateralusX @luhenry
/msvc/*profiler* @alexrp @luhenry
/msvc @lateralusX @kg @akoeplinger
/msvc/scripts @akoeplinger @kg
/packaging @alexischr @akoeplinger @luhenry @directhex
/netcore @marek-safar @akoeplinger @egorbo
/packaging @alexischr @akoeplinger @directhex
/packaging/MacSDK/msbuild.py @radical @akoeplinger
/runtime @akoeplinger @marek-safar @luhenry
/runtime @akoeplinger @marek-safar
/samples @luhenry @lewurm
/samples/profiler @alexrp @luhenry
/samples/size @alexrp @luhenry
/samples @lambdageek @lewurm
/samples/profiler @alexrp @lambdageek
/samples/size @alexrp @lambdageek
/scripts @akoeplinger @luhenry
/scripts/ci @akoeplinger @alexischr
/scripts @akoeplinger @directhex
/scripts/ci @akoeplinger @directhex
/sdks @marek-safar @luhenry @vargaz
/sdks/builds/android* @luhenry @jonpryor
/sdks/builds/mxe* @luhenry @jonpryor
/sdks @marek-safar @lewurm @vargaz
/sdks/builds/android* @alexischr @jonpryor
/sdks/builds/mxe* @alexischr @jonpryor
/sdks/builds/ios* @vargaz @rolfbjarne
/sdks/builds/wasm* @vargaz @kjpou1
/sdks/wasm @vargaz @kjpou1 @kg
/sdks/builds/wasm* @vargaz @kjpou1 @lewing
/sdks/wasm @vargaz @kjpou1 @kg @lewing
/sdks/ios @vargaz @rolfbjarne
/sdks/android @luhenry @jonpryor
/sdks/android @alexischr @jonpryor
/support @luhenry @vargaz
/support @lambdageek @vargaz
/tools @luhenry @vargaz
/tools @lambdageek @vargaz
/tools/locale-builder @marek-safar @egorbo
/tools/monograph @vargaz @vargaz
/tools/nuget-hash-extractor @marek-safar @radical
/tools/nuget-hash-extractor @marek-safar @radical @akoeplinger
/tools/offsets-tool @lewurm @rolfbjarne
/tools/pedump @lambdageek @lewurm
/tools/sgen @brzvlad @vargaz
+3
View File
@@ -65,3 +65,6 @@
[submodule "external/helix-binaries"]
path = external/helix-binaries
url = git://github.com/mono/helix-binaries.git
[submodule "external/illinker-test-assets"]
path = external/illinker-test-assets
url = git://github.com/mono/illinker-test-assets.git
-2
View File
@@ -28,8 +28,6 @@ Mono itself, and does not end up in the redistributable part of Mono:
* mcs/jay: 4-clause BSD licensed
* mcs/nunit24: MS-PL
* mcs/class/I18N/mklist.sh, tools/cvt.sh: GNU GPLv2
Runtime Code
+3 -4
View File
@@ -21,13 +21,12 @@ endif
SUBDIRS = $(build_with_msvc) mk po $(libgc_dir) llvm mono $(ikvm_native_dir) support data runtime scripts man samples $(tools_dir) $(build_without_msvc) $(docs_dir) acceptance-tests
# Keep in sync with SUBDIRS
DIST_SUBDIRS = $(build_with_msvc) m4 mk po $(libgc_dir) llvm mono ikvm-native support data runtime scripts man samples tools $(build_without_msvc) docs acceptance-tests
DIST_SUBDIRS = $(build_with_msvc) m4 mk po $(libgc_dir) llvm mono ikvm-native support data runtime scripts man samples tools $(build_without_msvc) docs acceptance-tests netcore
all: update_submodules
SUBMODULE_ERROR='Could not recursively update all git submodules. You may experience compilation problems if some submodules are out of date'
update_submodules:
@$(srcdir)/scripts/update_submodules.sh
@cd $(srcdir) && scripts/update_submodules.sh
.PHONY: update_submodules
@@ -59,7 +58,7 @@ dist-hook:
rm -f `find $(top_distdir)/external -name '\.dirstamp'`
rm -f `find $(top_distdir)/external -path '*\.exe' -not -path '*/roslyn-binaries/*'`
rm -f `find $(top_distdir)/external -path '*\.dll' -not -path '*/binary-reference-assemblies/*' -not -path '*/roslyn-binaries/*' -not -path '*/helix-binaries/*'`
rm -rf "$(top_distdir)/external/linker/linker/Tests"
rm -rf "$(top_distdir)/external/linker/test"
pkgconfigdir = $(libdir)/pkgconfig
noinst_DATA = mono-uninstalled.pc
+2 -2
View File
@@ -10,7 +10,7 @@
{
"name": "coreclr",
"url": "git://github.com/mono/coreclr.git",
"rev": "f3d9c9f742f9dcb5faf40080db5e7f464dab7e7c",
"rev": "90f7060935732bb624e1f325d23f63072433725f",
"remote-branch": "origin/mono",
"branch": "mono",
"directory": "coreclr"
@@ -18,7 +18,7 @@
{
"name": "ms-test-suite",
"url": "[email protected]:xamarin/ms-test-suite.git",
"rev": "67f29dfc0741b5311dd746c75760963a2915e648",
"rev": "39b1b222e8a3690a1b8ea018ce54d2a826f5246e",
"remote-branch": "origin/master",
"branch": "master",
"directory": "ms-test-suite"
-1
View File
@@ -3175,7 +3175,6 @@ CORECLR_COREMANGLIB_TEST_CS_SRC= \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/inattribute/inattributector.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/layoutkind/layoutkindauto.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/layoutkind/layoutkindsequential.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/marshal/marshalgetlastwin32error.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/marshal/marshalreadint641.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/marshal/marshalsizeof1.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/marshalasattribute/marshalasattributearraysubtype.cs \
+2
View File
@@ -1,4 +1,6 @@
check-roslyn:
@echo "Runnning roslyn tests using mono from PATH:"
mono --version
@$(MAKE) validate-roslyn RESET_VERSIONS=1
cd $(ROSLYN_PATH); \
./build.sh --restore --build --test --mono || exit; \
+14 -236
View File
@@ -1,6 +1,6 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
MinimumVisualStudioVersion = 15.0.0.0
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jay", "mcs/jay/jay.vcxproj", "{5d485d32-3b9f-4287-ab24-c8da5b89f537}"
EndProject
@@ -570,24 +570,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_System.Drawing.Prim
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_System.Net.Http.Rtc", "mcs/class/Facades/System.Net.Http.Rtc/Facades_System.Net.Http.Rtc.csproj", "{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NUnit.Framework", "mcs/nunit24/NUnitFramework/framework/NUnit.Framework.csproj", "{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.core.interfaces", "mcs/nunit24/NUnitCore/interfaces/nunit.core.interfaces.csproj", "{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.core", "mcs/nunit24/NUnitCore/core/nunit.core.csproj", "{559F5BCC-3235-494A-9D86-4F26F67F9E40}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.util", "mcs/nunit24/ClientUtilities/util/nunit.util.csproj", "{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.mocks", "mcs/nunit24/NUnitMocks/mocks/nunit.mocks.csproj", "{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.framework.extensions", "mcs/nunit24/NUnitExtensions/framework/nunit.framework.extensions.csproj", "{DFE253AA-843E-4374-B862-9F0B7414CB8C}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.core.extensions", "mcs/nunit24/NUnitExtensions/core/nunit.core.extensions.csproj", "{6464D30A-2B8E-458D-B96A-2ECDE947B58B}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit-console-runner", "mcs/nunit24/ConsoleRunner/nunit-console/nunit-console-runner.csproj", "{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit-console", "mcs/nunit24/ConsoleRunner/nunit-console-exe/nunit-console.csproj", "{2D845BF5-42C7-41D3-AC01-F63980F76B22}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ilasm", "mcs/ilasm/ilasm.csproj", "{C02B3C37-DB98-40A5-84F0-F98633DA7EE4}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "al", "mcs/tools/al/al.csproj", "{0A20671F-CCA9-457D-886C-0828C7D64128}"
@@ -1126,22 +1108,14 @@ Global
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|orbis.ActiveCfg = Debug|orbis
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|orbis.Build.0 = Debug|orbis
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|orbis.ActiveCfg = Release|orbis
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|orbis.Build.0 = Release|orbis
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|unreal.ActiveCfg = Debug|unreal
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|unreal.Build.0 = Debug|unreal
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|unreal.ActiveCfg = Release|unreal
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|unreal.Build.0 = Release|unreal
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|wasm.ActiveCfg = Debug|wasm
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|wasm.Build.0 = Debug|wasm
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|wasm.ActiveCfg = Release|wasm
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|wasm.Build.0 = Release|wasm
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|winaot.ActiveCfg = Debug|winaot
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|winaot.Build.0 = Debug|winaot
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|winaot.ActiveCfg = Release|winaot
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|winaot.Build.0 = Release|winaot
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|orbis.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|orbis.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|unreal.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|unreal.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|wasm.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|wasm.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|winaot.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|winaot.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|xammac.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|xammac.ActiveCfg = Release|net_4_x
{4900DA48-CB1B-4520-98EE-F6B0F3054341}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
@@ -3482,8 +3456,10 @@ Global
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|unreal.ActiveCfg = Release|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Debug|wasm.ActiveCfg = Debug|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|wasm.ActiveCfg = Release|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Debug|winaot.ActiveCfg = Debug|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|winaot.ActiveCfg = Release|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Debug|winaot.ActiveCfg = Debug|winaot
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Debug|winaot.Build.0 = Debug|winaot
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|winaot.ActiveCfg = Release|winaot
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|winaot.Build.0 = Release|winaot
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Debug|xammac.ActiveCfg = Debug|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|xammac.ActiveCfg = Release|net_4_x
{1B87A378-65E8-4899-9C9A-C940429D643C}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
@@ -10114,204 +10090,6 @@ Global
{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}.Release|winaot.ActiveCfg = Release|net_4_x
{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}.Debug|xammac.ActiveCfg = Debug|net_4_x
{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}.Release|xammac.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|net_4_x.Build.0 = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|net_4_x.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|net_4_x.Build.0 = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|monodroid.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|monotouch.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|orbis.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|orbis.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|unreal.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|unreal.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|wasm.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|wasm.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|winaot.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|winaot.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|xammac.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|xammac.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|net_4_x.Build.0 = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|net_4_x.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|net_4_x.Build.0 = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|monodroid.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|monotouch.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|orbis.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|orbis.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|unreal.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|unreal.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|wasm.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|wasm.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|winaot.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|winaot.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|xammac.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|xammac.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|net_4_x.Build.0 = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|net_4_x.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|net_4_x.Build.0 = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|monodroid.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|monotouch.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|orbis.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|orbis.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|unreal.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|unreal.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|wasm.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|wasm.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|winaot.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|winaot.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|xammac.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|xammac.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|net_4_x.Build.0 = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|net_4_x.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|net_4_x.Build.0 = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|monodroid.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|monotouch.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|orbis.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|orbis.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|unreal.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|unreal.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|wasm.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|wasm.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|winaot.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|winaot.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|xammac.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|xammac.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|net_4_x.Build.0 = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|net_4_x.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|net_4_x.Build.0 = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|monodroid.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|monotouch.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|orbis.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|orbis.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|unreal.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|unreal.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|wasm.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|wasm.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|winaot.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|winaot.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|xammac.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|xammac.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|net_4_x.Build.0 = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|net_4_x.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|net_4_x.Build.0 = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|monodroid.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|monotouch.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|orbis.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|orbis.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|unreal.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|unreal.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|wasm.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|wasm.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|winaot.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|winaot.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|xammac.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|xammac.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|net_4_x.Build.0 = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|net_4_x.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|net_4_x.Build.0 = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|monodroid.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|monotouch.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|orbis.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|orbis.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|unreal.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|unreal.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|wasm.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|wasm.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|winaot.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|winaot.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|xammac.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|xammac.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|net_4_x.Build.0 = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|net_4_x.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|net_4_x.Build.0 = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|monodroid.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|monotouch.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|orbis.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|orbis.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|unreal.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|unreal.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|wasm.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|wasm.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|winaot.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|winaot.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|xammac.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|xammac.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|net_4_x.Build.0 = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|net_4_x.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|net_4_x.Build.0 = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|monodroid.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|monotouch.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|orbis.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|orbis.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|unreal.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|unreal.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|wasm.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|wasm.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|winaot.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|winaot.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|xammac.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|xammac.ActiveCfg = Release|net_4_x
{C02B3C37-DB98-40A5-84F0-F98633DA7EE4}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{C02B3C37-DB98-40A5-84F0-F98633DA7EE4}.Debug|net_4_x.Build.0 = Debug|net_4_x
{C02B3C37-DB98-40A5-84F0-F98633DA7EE4}.Release|net_4_x.ActiveCfg = Release|net_4_x
+527 -161
View File
File diff suppressed because it is too large. Load diff
+3 -3
View File
@@ -7,7 +7,7 @@ EXTRA_DIST = \
config.in \
browscap.ini mono.supp mono.d README \
mono.pc.in mono-2.pc.in monosgen-2.pc.in mint.pc.in dotnet.pc.in dotnet35.pc.in wcf.pc.in monodoc.pc.in \
mono-nunit.pc.in mono-cairo.pc.in mono-options.pc.in cecil.pc.in \
mono-cairo.pc.in mono-options.pc.in cecil.pc.in \
mono-lineeditor.pc.in system.web.extensions_1.0.pc.in system.web.extensions.design_1.0.pc.in\
dtrace-prelink.sh system.web.mvc.pc.in system.web.mvc2.pc.in system.web.mvc3.pc.in aspnetwebstack.pc.in \
reactive.pc.in xbuild12.pc \
@@ -25,10 +25,10 @@ else
SGENPCFILE=
endif
pkgconfig_DATA= mono.pc mono-2.pc dotnet.pc dotnet35.pc wcf.pc mono-nunit.pc mono-cairo.pc mono-options.pc cecil.pc monodoc.pc mono-lineeditor.pc system.web.extensions_1.0.pc \
pkgconfig_DATA= mono.pc mono-2.pc dotnet.pc dotnet35.pc wcf.pc mono-cairo.pc mono-options.pc cecil.pc monodoc.pc mono-lineeditor.pc system.web.extensions_1.0.pc \
system.web.extensions.design_1.0.pc system.web.mvc.pc system.web.mvc2.pc system.web.mvc3.pc aspnetwebstack.pc reactive.pc xbuild12.pc $(SGENPCFILE)
DISTCLEANFILES= mono-2.pc mono.pc mint.pc dotnet.pc dotnet35.pc wcf.pc mono-nunit.pc mono-cairo.pc mono-options.pc cecil.pc monodoc.pc mono-lineeditor.pc system.web.extensions_1.0.pc \
DISTCLEANFILES= mono-2.pc mono.pc mint.pc dotnet.pc dotnet35.pc wcf.pc mono-cairo.pc mono-options.pc cecil.pc monodoc.pc mono-lineeditor.pc system.web.extensions_1.0.pc \
system.web.extensions.design_1.0.pc system.web.mvc.pc system.web.mvc2.pc system.web.mvc3.pc aspnetwebstack.pc reactive.pc $(SGENPCFILE) mono-sgen-gdb.py
mono_DATA = config \
Regular → Executable
View File
File mode changed.
+1 -1
View File
@@ -20,7 +20,7 @@ def print_frames(thread, num_frames, current_thread):
ipoffset = frame.EvaluateExpression('ip').GetValueAsUnsigned()
insn = ''
if ipoffset != 0:
ipoffset -= frame.EvaluateExpression('rtm->code').GetValueAsUnsigned()
ipoffset -= frame.EvaluateExpression('imethod->code').GetValueAsUnsigned()
insn = "\"" + frame.EvaluateExpression('mono_interp_opname [*ip]').summary[1:-1] + "\""
var = '%s::%s @ %d %s || %s' % (klassname, methodname, ipoffset, insn, frame)
except Exception as e:
-9
View File
@@ -1,9 +0,0 @@
prefix=${pcfiledir}/../..
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
Name: Mono NUnit
Description: Mono's version of NUnit
Version: @VERSION@
Libs: -r:${libdir}/mono/4.5/nunit.core.dll -r:${libdir}/mono/4.5/nunit.core.interfaces.dll -r:${libdir}/mono/4.5/nunit.core.extensions.dll -r:${libdir}/mono/4.5/nunit.framework.dll -r:${libdir}/mono/4.5/nunit.framework.extensions.dll -r:${libdir}/mono/4.5/nunit.mocks.dll -r:${libdir}/mono/4.5/nunit.util.dll -r:${libdir}/mono/4.5/nunit-console-runner.dll
+1 -1
+1 -1
+1 -1
+1 -1
+1 -1
+1 -1
+8 -2
View File
@@ -5,6 +5,14 @@
#define GC_PTHREAD_REDIRECTS_H
#ifdef __cplusplus
extern "C" {
#endif
void * GC_dlopen(const char *path, int mode);
#ifdef __cplusplus
} // extern "C"
#endif
#if defined(GC_SOLARIS_THREADS)
/* We need to intercept calls to many of the threads primitives, so */
/* that we can locate thread stacks and stop the world. */
@@ -26,7 +34,6 @@ extern "C" {
int GC_thr_join(thread_t wait_for, thread_t *departed, void **status);
int GC_thr_suspend(thread_t target_thread);
int GC_thr_continue(thread_t target_thread);
void * GC_dlopen(const char *path, int mode);
# define thr_create GC_thr_create
# define thr_join GC_thr_join
# define thr_suspend GC_thr_suspend
@@ -66,7 +73,6 @@ extern "C" {
# define dlopen GC_dlopen
#endif /* SOLARIS_THREADS || SOLARIS_PTHREADS */
#if !defined(GC_USE_LD_WRAP) && (defined(GC_PTHREADS) || defined(GC_DARWIN_THREADS) || defined(GC_MACOSX_THREADS)) && !defined(GC_SOLARIS_PTHREADS)
/* We treat these similarly. */
# include <pthread.h>
+6 -2
View File
@@ -9,11 +9,15 @@ else
llvm_config=llvm-config
endif
if HAVE_STATIC_ZLIB
llvm_extra_libs = $(STATIC_ZLIB_PATH)
else
if HAVE_ZLIB
llvm_extra_libs=-lz
else
llvm_extra_libs=
endif
endif
if INTERNAL_LLVM
@@ -22,7 +26,7 @@ all-local: configure-llvm build-llvm install-llvm llvm_config.mk
clean-local: clean-llvm clean-llvm-config
$(mono_build_root)/llvm/llvm_config.mk: install-llvm
$(top_srcdir)/llvm/build_llvm_config.sh "$(top_srcdir)/llvm/usr/bin/$(llvm_config)" "$(LLVM_CODEGEN_LIBS)" "$(llvm_extra_libs)" > $@
$(top_srcdir)/llvm/build_llvm_config.sh "$(top_srcdir)/llvm/usr/bin/$(llvm_config)" "$(LLVM_CODEGEN_LIBS)" "$(llvm_extra_libs)" | tee $@
else
all-local: llvm_config.mk
@@ -30,7 +34,7 @@ all-local: llvm_config.mk
clean-local: clean-llvm-config
$(mono_build_root)/llvm/llvm_config.mk: $(top_srcdir)/llvm/Makefile.am
$(top_srcdir)/llvm/build_llvm_config.sh "$(EXTERNAL_LLVM_CONFIG)" "$(LLVM_CODEGEN_LIBS)" "$(llvm_extra_libs)" > $@
$(top_srcdir)/llvm/build_llvm_config.sh "$(EXTERNAL_LLVM_CONFIG)" "$(LLVM_CODEGEN_LIBS)" "$(llvm_extra_libs)" | tee $@
endif
llvm_config.mk: $(mono_build_root)/llvm/llvm_config.mk
+4 -6
View File
@@ -12,13 +12,11 @@ LLVM_DOWNLOAD_LOCATION = "http://xamjenkinsartifact.blob.core.windows.net/build-
CMAKE := $(or $(CMAKE),$(shell which cmake))
NINJA := $(shell which ninja)
$(LLVM_BUILD) $(LLVM_PREFIX):
mkdir -p $@
EXTRA_LLVM_ARGS = $(if $(filter $(LLVM_TARGET),wasm32), -DLLVM_BUILD_32_BITS=On -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD="WebAssembly",)
# -DLLVM_ENABLE_LIBXML2=Off is needed because xml2 is not used and it breaks 32-bit builds on 64-bit Linux hosts
$(LLVM_BUILD)/$(if $(NINJA),build.ninja,Makefile): $(abs_top_srcdir)/external/llvm/CMakeLists.txt | $(LLVM_BUILD) $(LLVM_PREFIX)
$(LLVM_BUILD)/$(if $(NINJA),build.ninja,Makefile): $(abs_top_srcdir)/external/llvm/CMakeLists.txt
mkdir -p $(LLVM_BUILD) $(LLVM_PREFIX)
cd $(LLVM_BUILD) && $(CMAKE) \
$(if $(NINJA),-G Ninja) \
-DCMAKE_INSTALL_PREFIX="$(LLVM_PREFIX)" \
@@ -34,7 +32,7 @@ $(LLVM_BUILD)/$(if $(NINJA),build.ninja,Makefile): $(abs_top_srcdir)/external/ll
-DLLVM_ENABLE_LIBXML2=Off \
-DHAVE_FUTIMENS=0 \
$(LLVM_CMAKE_ARGS) \
$(abs_top_srcdir)/external/llvm
$(dir $<)
.PHONY: configure-llvm
configure-llvm: $(LLVM_BUILD)/$(if $(NINJA),build.ninja,Makefile)
@@ -47,7 +45,7 @@ build-llvm: configure-llvm
DESTDIR="" $(if $(NINJA),$(NINJA),$(MAKE)) -C $(LLVM_BUILD)
.PHONY: install-llvm
install-llvm: build-llvm | $(LLVM_PREFIX)
install-llvm: build-llvm
DESTDIR="" $(if $(NINJA),$(NINJA),$(MAKE)) -C $(LLVM_BUILD) install
.PHONY: download-llvm
+2 -2
View File
@@ -139,10 +139,10 @@ fi
if [[ $llvm_config_cflags = *"stdlib=libc++"* ]]; then
llvm_libc_c="-stdlib=libc++"
llvm_libc_link="-lc++"
# llvm_libc_link="-lc++"
else
llvm_libc_c=""
llvm_libc_link="-lstdc++"
# llvm_libc_link="-lstdc++"
fi
if [[ $llvm_host_win32 = 1 ]]; then
+3
View File
@@ -335,6 +335,9 @@ format.
.SS Options
The AOT profiler supports the following options:
.TP
\fBduration\fR=\fInum\fR
Profile only NUM seconds of runtime and then write the data.
.TP
\fBhelp\fR
Print usage instructions.
.TP
+29 -44
View File
@@ -28,7 +28,7 @@ to it. The
.I file
is an ECMA assembly. They typically have a .exe or .dll extension.
.PP
These executables can reference additionaly functionality in the form
These executables can reference additional functionality in the form
of assembly references. By default those assembly references are
resolved as follows: the \fBmscorlib.dll\fR is resolved from the
system profile that is configured by Mono, and other assemblies are
@@ -37,8 +37,8 @@ loaded from the Global Assembly Cache (GAC).
The runtime contains a native code generator that transforms the
Common Intermediate Language into native code.
.PP
The code generator can operate in two modes: just in time compilation
(JIT) or ahead of time compilation (AOT). Since code can be
The code generator can operate in two modes: Just-in-time compilation
(JIT) or Ahead-of-time compilation (AOT). Since code can be
dynamically loaded, the runtime environment and the JIT are always
present, even if code is compiled ahead of time.
.PP
@@ -216,17 +216,35 @@ options. This feature is experimental.
.TP
.I llvmopts=[options]
Use this option to add more flags to the built-in set of flags passed to the
LLVM optimizer. The list of possible flags that can be passed can be
obtained by calling the bundled
LLVM optimizer. When you invoke the
.I mono
command with the
.I --aot=llvm
it displays the current list of flags that are being passed to the
.I opt
program that comes with Mono.
command.
.I The list of possible flags that can be passed can be
obtained by calling the bundled
.I opt
program that comes with Mono, and calling it like this:
.nf
opt --help
.fi
.TP
.I llvmllc=[options]
Use this option to add more flags to the built-in set of flags passed to the
LLVM static compiler (llc). The list of possible flags that can be passed can be
obtained by calling the bundled
.I llc
program that comes with Mono.
program that comes with Mono, and calling it like this:
.nf
llc --help
.fi
.TP
.I llvm-outfile=[filename]
Gives the path for the temporary LLVM bitcode file created during AOT.
@@ -618,47 +636,14 @@ running a 1.1 program on a 2.0 version:
mono --runtime=v2.0.50727 program.exe
.fi
.TP
\fB--security\fR, \fB--security=mode\fR
Activate the security manager, a currently experimental feature in
Mono and it is OFF by default. The new code verifier can be enabled
with this option as well.
.RS
.ne 8
.PP
Using security without parameters is equivalent as calling it with the
"cas" parameter.
.PP
The following modes are supported:
.TP
.I core-clr
Enables the core-clr security system, typically used for
Moonlight/Silverlight applications. It provides a much simpler
security system than CAS, see http://www.mono-project.com/docs/web/moonlight/
for more details and links to the descriptions of this new system.
.TP
.I validil
Enables the new verifier and performs basic verification for code
validity. In this mode, unsafe code and P/Invoke are allowed. This
mode provides a better safety guarantee but it is still possible
for managed code to crash Mono.
.TP
.I verifiable
Enables the new verifier and performs full verification of the code
being executed. It only allows verifiable code to be executed.
Unsafe code is not allowed but P/Invoke is. This mode should
not allow managed code to crash mono. The verification is not as
strict as ECMA 335 standard in order to stay compatible with the MS
runtime.
.PP
The security system acts on user code: code contained in mscorlib or
the global assembly cache is always trusted.
.ne
.RE
.TP
\fB--server\fR
Configures the virtual machine to be better suited for server
operations (currently, allows a heavier threadpool initialization).
.TP
\fB--use-map-jit\fR
Instructs Mono to generate code using MAP_JIT on MacOS. Necessary for
bundled applications.
.TP
\fB--verify-all\fR
Verifies mscorlib and assemblies in the global
assembly cache for valid IL, and all user code for IL
+1 -1
View File
@@ -27,7 +27,7 @@ The Private Key File (pvk) that contains the private key used to digitally
sign the PE executable. This private key must match the public key inside the
publisher X.509 certificate.
.TP
.I "-a sha1 | md5"
.I "-a sha1 | md5 | sha2 | sha256 | sha384 | sha512"
The hash algorithm used in the digital signature of the PE executable. The
default algorithm is SHA1.
.TP
+4 -3
View File
@@ -1,6 +1,6 @@
thisdir := .
SUBDIRS := build jay mcs class nunit24 ilasm tools tests errors docs packages
SUBDIRS := build jay mcs class ilasm tools tests errors docs packages
# Resgen is corlib specific tool
@@ -19,7 +19,7 @@ testing_aot_full_interp_SUBDIRS := build class
testing_aot_hybrid_SUBDIRS := build class
testing_aot_full_SUBDIRS := build class
binary_reference_assemblies_SUBDIRS := build class
net_4_x_SUBDIRS := build class nunit24 ilasm tools tests errors docs mcs class/aot-compiler packages
net_4_x_SUBDIRS := build class ilasm tools tests errors docs mcs class/aot-compiler packages
xammac_net_4_5_SUBDIRS := build class
xbuild_12_SUBDIRS := build class tools/xbuild
xbuild_14_SUBDIRS := build class tools/xbuild
@@ -28,6 +28,7 @@ orbis_SUBDIRS := build class
unreal_SUBDIRS := build class
wasm_SUBDIRS := build class
wasm_tools_SUBDIRS := build class tools
netcore_SUBDIRS := build class
include build/rules.make
@@ -154,7 +155,7 @@ distcheck: dist-tarball
MONO_API_SNAPSHOT_PATH := $(topdir)../external/api-snapshot/
GENAPI := $(MONO_API_SNAPSHOT_PATH)tools/genapi/Microsoft.DotNet.GenAPI.exe
MONO_API_SNAPSHOT_PROFILE_PATH := $(MONO_API_SNAPSHOT_PATH)profiles/$(PROFILE)/
MONO_API_ASSEMBLIES_IGNORED := $(addprefix $(topdir)class/lib/$(PROFILE)/, Mono.CSharp.dll SystemWebTestShim.dll standalone-runner-support.dll nunit.core.dll nunit.core.extensions.dll nunit.core.interfaces.dll nunit.framework.dll nunit.framework.extensions.dll nunit.mocks.dll nunit.util.dll nunit-console-runner.dll nunitlite.dll Mono.Profiler.Log.dll)
MONO_API_ASSEMBLIES_IGNORED := $(addprefix $(topdir)class/lib/$(PROFILE)/, Mono.CSharp.dll SystemWebTestShim.dll standalone-runner-support.dll nunitlite.dll Mono.Profiler.Log.dll)
MONO_API_ASSEMBLIES := $(filter-out $(MONO_API_ASSEMBLIES_IGNORED), $(wildcard $(topdir)class/lib/$(PROFILE)/*.dll)) $(wildcard $(topdir)class/lib/$(PROFILE)/Facades/*.dll)
MONO_API_ASSEMBLIES_CS := $(MONO_API_ASSEMBLIES:$(topdir)class/lib/$(PROFILE)/%.dll=$(MONO_API_SNAPSHOT_PROFILE_PATH)%.cs)
-3
View File
@@ -34,9 +34,6 @@ package module which drives the compilation of this directory.
mcs/
The Mono C# compiler
nunit24/
An old copy of the NUnit 2.4 library that we ship for historical reasons.
packages/
Integrates some packages from NuGet (like Roslyn) into the build system.
+17 -2
View File
@@ -28,7 +28,14 @@
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
static class Consts
static partial class Consts
{
public const string MonoCorlibVersion = "@MONO_CORLIB_VERSION@";
}
#if !NETCORE
static partial class Consts
{
//
// Use these assembly version constants to make code more maintainable.
@@ -38,7 +45,6 @@ static class Consts
public const string MonoCompany = "Mono development team";
public const string MonoProduct = "Mono Common Language Infrastructure";
public const string MonoCopyright = "(c) Various Mono authors";
public const string MonoCorlibVersion = "@MONO_CORLIB_VERSION@";
#if MOBILE
// Versions of .NET Framework for Silverlight 4.0
@@ -62,6 +68,13 @@ static class Consts
public const string VsVersion = "0.0.0.0"; // Useless ?
public const string VsFileVersion = "11.0.0.0"; // TODO:
#elif NETCORE
public const string FxVersion = "";
public const string FxFileVersion = "";
public const string EnvironmentVersion = FxFileVersion;
public const string VsVersion = "";
public const string VsFileVersion = "";
#elif NET_4_0
#error Profile NET_4_0 is not supported.
#elif NET_3_5
@@ -119,3 +132,5 @@ static class Consts
public const string AssemblyPresentationFramework_3_5 = "PresentationFramework, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";
public const string AssemblySystemServiceModel_3_0 = "System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
}
#endif
+5
View File
@@ -41,6 +41,11 @@ static partial class SR
return string.Format (CultureInfo.InvariantCulture, resourceFormat, p1, p2);
}
internal static string Format(CultureInfo ci, string resourceFormat, object p1, object p2)
{
return string.Format (ci, resourceFormat, p1, p2);
}
internal static string Format(string resourceFormat, object p1, object p2, object p3)
{
return string.Format (CultureInfo.InvariantCulture, resourceFormat, p1, p2, p3);
+4 -3
View File
@@ -291,6 +291,7 @@ endif
# If the directory contains the per profile include file, generate list file.
# TODO: depend on all *.sources (except tests) for now and figure out how to list only needed files later
PROFILE_sources = $(filter-out %test.dll.exclude.sources %test.dll.sources, $(wildcard *.sources))
PROFILE_excludes = $(filter-out %test.dll.exclude.sources %test.dll.sources, $(wildcard *.exclude.sources))
sourcefile = $(depsdir)/$(PROFILE_PLATFORM)_$(PROFILE)_$(LIBRARY_SUBDIR)_$(LIBRARY).sources
$(sourcefile): $(PROFILE_sources) $(PROFILE_excludes) $(depsdir)/.stamp
@@ -351,7 +352,7 @@ library_CLEAN_FILES += $(PROFILE)_$(LIBRARY_NAME)_aot.log
ifdef PLATFORM_AOT_SUFFIX
$(the_lib)$(PLATFORM_AOT_SUFFIX): $(the_lib)
$(Q_AOT) MONO_PATH='$(the_libdir_base)' > $(PROFILE)_$(LIBRARY_NAME)_aot.log 2>&1 $(RUNTIME) $(AOT_BUILD_FLAGS) --debug $(the_lib)
$(Q_AOT) MONO_PATH='$(the_libdir_base)' $(RUNTIME) $(AOT_BUILD_FLAGS) --debug $(the_lib)
all-local-aot: $(the_lib)$(PLATFORM_AOT_SUFFIX)
endif
@@ -386,5 +387,5 @@ ifneq ($(RESX_STRINGS),)
endif
update-corefx-sr: $(RESX_RESOURCE_STRING) $(XTEST_RESX_RESOURCE_STRING)
make SR_OUTPUT=corefx/SR.cs RESX_STRINGS="$(RESX_RESOURCE_STRING)" RESX_EXTRA_ARGUMENTS="$(RESX_EXTRA_ARGUMENTS)" update-corefx-sr-generic \
&& make SR_OUTPUT=corefx/SR.tests.cs RESX_STRINGS=$(XTEST_RESX_RESOURCE_STRING) update-corefx-sr-generic
$(MAKE) SR_OUTPUT=corefx/SR.cs RESX_STRINGS="$(RESX_RESOURCE_STRING)" RESX_EXTRA_ARGUMENTS="$(RESX_EXTRA_ARGUMENTS)" update-corefx-sr-generic \
&& $(MAKE) SR_OUTPUT=corefx/SR.tests.cs RESX_STRINGS=$(XTEST_RESX_RESOURCE_STRING) update-corefx-sr-generic
+2
View File
@@ -34,3 +34,5 @@ platform-check:
# echo "*** You need to build MCS with GNU make. Try \`gmake'" ; \
# exit 1 ; \
# fi
PLATFORM_LINUX=1
+1 -1
View File
@@ -6,7 +6,7 @@
PLATFORM_MCS_FLAGS =
PLATFORM_RUNTIME = $(RUNTIME)
PLATFORM_CORLIB = mscorlib.dll
PLATFORM_TEST_HARNESS_EXCLUDES = NotOnMac,MacNotWorking,
PLATFORM_TEST_HARNESS_EXCLUDES = NotOnMac
EXTERNAL_MCS = mcs
EXTERNAL_MBAS = mbas
+3
View File
@@ -34,3 +34,6 @@ platform-check:
# echo "*** You need to build MCS with GNU make. Try \`gmake'" ; \
# exit 1 ; \
# fi
PLATFORM_UNIX=1
+1 -1
View File
@@ -6,7 +6,7 @@
PLATFORM_MCS_FLAGS =
PLATFORM_RUNTIME =
PLATFORM_CORLIB = mscorlib.dll
PLATFORM_TEST_HARNESS_EXCLUDES = NotOnWindows,
PLATFORM_TEST_HARNESS_EXCLUDES = NotOnWindows
EXTERNAL_MCS = mcs
EXTERNAL_MBAS = vbc.exe
+26 -1
View File
@@ -58,7 +58,14 @@ LIBRARY_COMPILE = $(BOOT_COMPILE)
#
# Copy from rules.make because I don't know how to unset MCS_FLAGS
#
USE_MCS_FLAGS = /codepage:$(CODEPAGE) /nologo /noconfig /deterministic $(LOCAL_MCS_FLAGS) $(PLATFORM_MCS_FLAGS) $(PROFILE_MCS_FLAGS) $(MCS_FLAGS)
ifeq ("$(ENABLE_COMPILER_SERVER)","1")
COMPILER_SERVER_ARGS=/shared:$(COMPILER_SERVER_PIPENAME)
else
COMPILER_SERVER_ARGS:=
endif
USE_MCS_FLAGS = $(COMPILER_SERVER_ARGS) /codepage:$(CODEPAGE) /nologo /noconfig /deterministic $(LOCAL_MCS_FLAGS) $(PLATFORM_MCS_FLAGS) $(PROFILE_MCS_FLAGS) $(MCS_FLAGS)
.PHONY: profile-check do-profile-check
profile-check:
@@ -75,6 +82,7 @@ clean-profile:
post-profile-cleanup:
@rm -f $(monolite_flag)
$(MAKE) $(MAKE_Q) start-compiler-server
PROFILE_EXE = $(depsdir)/basic-profile-check.exe
PROFILE_OUT = $(PROFILE_EXE:.exe=.out)
@@ -127,3 +135,20 @@ $(PROFILE_EXE): $(topdir)/build/common/basic-profile-check.cs
$(PROFILE_OUT): $(PROFILE_EXE)
$(PROFILE_RUNTIME) $< > $@ 2>&1
ifeq ("$(ENABLE_COMPILER_SERVER)","1")
BUILDLIB_LOCATION=$(realpath $(topdir))/class/lib/build
MONOWRAPPER_LOCATION=$(realpath $(topdir)/../runtime/mono-wrapper)
VBCS_LOCATION?=$(dir $(SERVER_CSC_LOCATION))/VBCSCompiler.exe
VBCS_RUNTIME=MONO_PATH="$(BUILDLIB_LOCATION)$(PLATFORM_PATH_SEPARATOR)$(BUILDLIB_LOCATION)/Facades$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" '$(MONOWRAPPER_LOCATION)'
export VBCS_RUNTIME
export VBCS_LOCATION
start-compiler-server:
echo Attempting to start compiler server...
$(topdir)/build/start-compiler-server.sh '$(realpath $(topdir))' '$(realpath $(topdir)/build/compiler-server.log)' '$(COMPILER_SERVER_PIPENAME)'
else
start-compiler-server:
endif
+2
View File
@@ -34,3 +34,5 @@ NO_INSTALL = yes
MOBILE_DYNAMIC = yes
MOBILE_PROFILE = yes
NO_CONSOLE = yes
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking PKITS InetAccess AndroidNotWorking
+1 -1
View File
@@ -11,7 +11,7 @@ profile-check:
TARGET_NET_REFERENCE = v4.6
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = -d:NET_4_6 -d:MONO -d:WIN_PLATFORM -nowarn:1699 -nostdlib $(PLATFORM_DEBUG_FLAGS)
PROFILE_MCS_FLAGS = -d:NET_4_6 -d:MONO -d:MONODROID_TOOLS -d:WIN_PLATFORM -nowarn:1699 -nostdlib $(PLATFORM_DEBUG_FLAGS)
FRAMEWORK_VERSION = 4.5
+3 -1
View File
@@ -3,4 +3,6 @@ include $(topdir)/build/profiles/monotouch_runtime.make
PROFILE_MCS_FLAGS += \
-d:FULL_AOT_RUNTIME
NO_SRE=1
NO_SRE = yes
PROFILE_TEST_HARNESS_EXCLUDES += SRE NotWorkingLinqInterpreter
+3 -1
View File
@@ -39,4 +39,6 @@ NO_CONSOLE = yes
PROFILE_DISABLE_BTLS=1
MONO_FEATURE_APPLETLS=1
ONLY_APPLETLS=1
ENABLE_GSS=1
ENABLE_GSS=1
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking PKITS InetAccess
+1 -1
View File
@@ -11,7 +11,7 @@ profile-check:
TARGET_NET_REFERENCE = v4.6
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = -d:NET_4_6 -d:MONO -d:WIN_PLATFORM -nowarn:1699 -nostdlib $(PLATFORM_DEBUG_FLAGS)
PROFILE_MCS_FLAGS = -d:NET_4_6 -d:MONO -d:MONOTOUCH_TOOLS -d:WIN_PLATFORM -nowarn:1699 -nostdlib $(PLATFORM_DEBUG_FLAGS)
FRAMEWORK_VERSION = 4.5
+16
View File
@@ -0,0 +1,16 @@
# -*- makefile -*-
BOOTSTRAP_PROFILE = build
BOOTSTRAP_MCS = MONO_PATH="$(topdir)/class/lib/$(BOOTSTRAP_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(INTERNAL_CSC)
MCS = $(BOOTSTRAP_MCS)
PLATFORMS = macos linux win32 unix
profile-check:
@:
DEFAULT_REFERENCES =
PROFILE_MCS_FLAGS = -d:NETCORE -nostdlib $(PLATFORM_DEBUG_FLAGS)
ENFORCE_LIBRARY_WARN_AS_ERROR = yes
+2 -3
View File
@@ -40,7 +40,6 @@ MOBILE_PROFILE = yes
NO_VTS_TEST = yes
NO_CONSOLE = yes
PROFILE_DISABLE_BTLS = yes
NO_SRE=1
NO_SRE = yes
# Note need for trailing comma. If you add, keep it
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking,PKITS,
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking PKITS SRE NotWorkingLinqInterpreter
+1 -2
View File
@@ -30,5 +30,4 @@ NO_INSTALL = yes
NO_CONSOLE = yes
MOBILE_PROFILE = yes
# Note need for trailing comma. If you add, keep it
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking,PKITS,
PROFILE_TEST_HARNESS_EXCLUDES := MobileNotWorking PKITS
+2
View File
@@ -14,3 +14,5 @@ NO_SRE = yes
ALWAYS_AOT_BCL = yes
ALWAYS_AOT_TESTS = yes
PROFILE_TEST_HARNESS_EXCLUDES += SRE
+1 -1
View File
@@ -40,7 +40,7 @@ ALWAYS_AOT_TESTS = yes
MOBILE_PROFILE = yes
NO_VTS_TEST = yes
NO_CONSOLE = yes
NO_SRE=1
NO_MULTIPLE_APPDOMAINS = yes
NO_THREAD_ABORT = yes
NO_THREAD_SUSPEND_RESUME = yes
WASM = yes
+1 -1
View File
@@ -11,7 +11,7 @@ profile-check:
TARGET_NET_REFERENCE = v4.6
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = -d:NET_4_6 -d:MONO -nowarn:1699 -nostdlib $(PLATFORM_DEBUG_FLAGS)
PROFILE_MCS_FLAGS = -d:NET_4_6 -d:MONO -d:WASM_TOOLS -nowarn:1699 -nostdlib $(PLATFORM_DEBUG_FLAGS)
FRAMEWORK_VERSION = 4.5
+2 -3
View File
@@ -38,7 +38,6 @@ ALWAYS_AOT_BCL = yes
ALWAYS_AOT_TESTS = yes
MOBILE_PROFILE = yes
NO_VTS_TEST = yes
NO_SRE=1
NO_SRE = yes
# Note need for trailing comma. If you add, keep it
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking,PKITS,
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking PKITS SRE NotWorkingLinqInterpreter
+2 -1
View File
@@ -29,7 +29,6 @@ PROFILE_MCS_FLAGS = \
API_BIN_PROFILE = build/monotouch
FRAMEWORK_VERSION = 2.1
NO_TEST = yes
NO_INSTALL = yes
MOBILE_DYNAMIC = yes
MOBILE_PROFILE = yes
@@ -39,3 +38,5 @@ ENABLE_GSS=1
PROFILE_DISABLE_BTLS=1
MONO_FEATURE_APPLETLS=1
ONLY_APPLETLS=1
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking PKITS
+13 -4
View File
@@ -9,6 +9,7 @@
empty :=
space := $(empty) $(empty)
comma := ,
_FILTER_OUT = $(foreach x,$(2),$(if $(findstring $(1),$(x)),,$(x)))
# given $(thisdir), we compute the path to the top directory
@@ -30,8 +31,16 @@ ifndef BUILD_TOOLS_PROFILE
BUILD_TOOLS_PROFILE = build
endif
USE_MCS_FLAGS = /codepage:$(CODEPAGE) /nologo /noconfig /deterministic $(LOCAL_MCS_FLAGS) $(PLATFORM_MCS_FLAGS) $(PROFILE_MCS_FLAGS) $(MCS_FLAGS)
USE_MBAS_FLAGS = /codepage:$(CODEPAGE) $(LOCAL_MBAS_FLAGS) $(PLATFORM_MBAS_FLAGS) $(PROFILE_MBAS_FLAGS) $(MBAS_FLAGS)
ifeq ("$(ENABLE_COMPILER_SERVER)","1")
COMPILER_SERVER_ARGS=/shared:$(COMPILER_SERVER_PIPENAME)
CSC_LOCATION=$(SERVER_CSC_LOCATION)
else
COMPILER_SERVER_ARGS:=
CSC_LOCATION=$(STANDALONE_CSC_LOCATION)
endif
USE_MCS_FLAGS = $(COMPILER_SERVER_ARGS) /codepage:$(CODEPAGE) /nologo /noconfig /deterministic $(LOCAL_MCS_FLAGS) $(PLATFORM_MCS_FLAGS) $(PROFILE_MCS_FLAGS) $(MCS_FLAGS)
USE_MBAS_FLAGS = $(COMPILER_SERVER_ARGS) /codepage:$(CODEPAGE) $(LOCAL_MBAS_FLAGS) $(PLATFORM_MBAS_FLAGS) $(PROFILE_MBAS_FLAGS) $(MBAS_FLAGS)
USE_CFLAGS = $(LOCAL_CFLAGS) $(CFLAGS) $(CPPFLAGS)
CSCOMPILE = $(Q_MCS) $(MCS) $(USE_MCS_FLAGS)
CSC_RUNTIME_FLAGS = --aot-path=$(abspath $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)) --gc-params=nursery-size=64m
@@ -196,12 +205,12 @@ endif
%.dll$(PLATFORM_AOT_SUFFIX): %.dll
@ mkdir -p $<_bitcode_tmp
$(Q_AOT) MONO_PATH="$(topdir)/class/lib/$(PROFILE)" $(RUNTIME) $(RUNTIME_FLAGS) $(AOT_BUILD_FLAGS),temp-path=$<_bitcode_tmp --verbose $< > [email protected]
$(Q_AOT) MONO_PATH="$(topdir)/class/lib/$(PROFILE)" $(RUNTIME) $(RUNTIME_FLAGS) $(AOT_BUILD_FLAGS),temp-path=$<_bitcode_tmp $<
@ rm -rf $<_bitcode_tmp
%.exe$(PLATFORM_AOT_SUFFIX): %.exe
@ mkdir -p $<_bitcode_tmp
$(Q_AOT) MONO_PATH="$(topdir)/class/lib/$(PROFILE)" $(RUNTIME) $(RUNTIME_FLAGS) $(AOT_BUILD_FLAGS),temp-path=$<_bitcode_tmp --verbose $< > [email protected]
$(Q_AOT) MONO_PATH="$(topdir)/class/lib/$(PROFILE)" $(RUNTIME) $(RUNTIME_FLAGS) $(AOT_BUILD_FLAGS),temp-path=$<_bitcode_tmp $<
@ rm -rf $<_bitcode_tmp
endif #ifneq ("$(wildcard $(topdir)/class/lib/$(PROFILE))","")
+24
View File
@@ -0,0 +1,24 @@
#!/usr/bin/env bash
# usage: start-compiler-server.sh <working directory> <log path> <pipename>
# ensure that VBCS_RUNTIME and VBCS_LOCATION environment variables are set.
set -u
set -e
if [ -s "$VBCS_LOCATION" ]; then
CMD="RoslynCommandLineLogFile=$2 $VBCS_RUNTIME --gc-params=nursery-size=64m \"$VBCS_LOCATION\" -pipename:$3 &"
echo . > "$2"
echo "cd $1; bash -c \"$CMD\""
cd "$1"
bash -c "$CMD"
RESULT=$?
if [ $RESULT -eq 0 ]; then
echo Compiler server started.
else
echo Failed to start compiler server.
fi;
else
echo No compiler server found at path "$VBCS_LOCATION". Ensure that VBCS_LOCATION is set in config.make or passed as a parameter to make.
echo Use ENABLE_COMPILER_SERVER=0 to disable the use of the compiler server and continue to build.
exit 1
fi;
+83 -48
View File
@@ -54,7 +54,8 @@ xunit_src += $(topdir)/../mcs/class/test-helpers/RemoteExecutorTestBase.Mono.cs
endif
endif
endif
endif
endif # ($(USE_XTEST_REMOTE_EXECUTOR), YES)
xunit_class_deps :=
@@ -64,36 +65,47 @@ xunit_libs_ref += $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE)/Facades/%.dll,$
xunit_libs_dep = $(xunit_class_deps:%=$(topdir)/class/lib/$(PROFILE)/$(PARENT_PROFILE)%.dll)
xunit_libs_ref += $(xunit_libs_dep:%=-r:%)
TEST_LIB_MCS_FLAGS = $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE)/%.dll,$(TEST_LIB_REFS) $(DEFAULT_REFERENCES))
TEST_LIB_REFS_ALL = $(TEST_LIB_REFS) $(DEFAULT_REFERENCES)
ifdef TARGET_NET_REFERENCE
# System*, mscorlib references come from the TARGET_NET_REFERENCE dir, others from the profile dir
TEST_LIB_REFS_MONO = $(call _FILTER_OUT,System,$(call _FILTER_OUT,mscorlib,$(TEST_LIB_REFS_ALL)))
TEST_LIB_REFS_SYSTEM = $(filter-out $(TEST_LIB_REFS_MONO),$(TEST_LIB_REFS_ALL))
TEST_LIB_MCS_FLAGS = $(patsubst %,-r:$(topdir)/../external/binary-reference-assemblies/$(TARGET_NET_REFERENCE)/%.dll,$(TEST_LIB_REFS_SYSTEM))
TEST_LIB_MCS_FLAGS += $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE_DIRECTORY)/%.dll,$(TEST_LIB_REFS_MONO))
else
TEST_LIB_MCS_FLAGS = $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE_DIRECTORY)/%.dll,$(TEST_LIB_REFS_ALL))
endif
XTEST_LIB_MCS_FLAGS = $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE)/%.dll,$(XTEST_LIB_REFS) $(DEFAULT_REFERENCES))
test_nunit_dep = $(test_nunit_lib:%=$(topdir)/class/lib/$(PROFILE)/$(PARENT_PROFILE)%)
test_nunit_ref = $(test_nunit_dep:%=-r:%)
tests_CLEAN_FILES += TestResult*.xml
test_sourcefile = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll.sources)
test_sourcefile_base = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll.sources)
ifeq ($(wildcard $(test_sourcefile)),)
test_sourcefile = $(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll.sources)
ifeq ($(wildcard $(test_sourcefile_base)),)
test_sourcefile_base = $(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll.sources)
endif
test_lib = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll)
test_lib_output = $(test_lib_dir)/$(test_lib)
test_sourcefile_excludes = $(test_lib).exclude.sources
test_sourcefile_base_excludes = $(test_lib).exclude.sources
test_pdb = $(test_lib:.dll=.pdb)
test_response = $(depsdir)/$(test_lib).response
test_makefrag = $(depsdir)/$(test_lib).makefrag
test_flags = $(test_nunit_ref) $(TEST_MCS_FLAGS) $(TEST_LIB_MCS_FLAGS)
ifndef NO_BUILD
test_flags += -r:$(the_assembly)
test_assembly_dep = $(the_assembly)
endif
tests_CLEAN_FILES += $(test_lib_output) $(test_lib_output:$(ASSEMBLY_EXT)=.pdb) $(test_response) $(test_makefrag)
tests_CLEAN_FILES += $(test_lib_output) $(test_lib_output:$(ASSEMBLY_EXT)=.pdb)
xtest_sourcefile = $(PROFILE_PLATFORM)_$(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.sources)
xtest_sourcefile_excludes = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.exclude.sources)
xtest_sourcefile_base = $(PROFILE_PLATFORM)_$(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.sources)
xtest_sourcefile_base_excludes_full = $(PROFILE_PLATFORM)_$(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.exclude.sources)
xtest_sourcefile_base_excludes = $(xtest_sourcefile_base_excludes_full:_%=%)
xunit_test_lib = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xunit-test.dll)
xtest_lib_output = $(test_lib_dir)/$(xunit_test_lib)
@@ -102,16 +114,16 @@ xtest_response = $(depsdir)/$(xunit_test_lib).response
xtest_makefrag = $(depsdir)/$(xunit_test_lib).makefrag
xtest_flags = -r:$(the_assembly) $(xunit_libs_ref) $(XTEST_MCS_FLAGS) $(XTEST_LIB_MCS_FLAGS) /unsafe
ifeq ($(wildcard $(xtest_sourcefile)),)
xtest_sourcefile = $(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.sources)
ifeq ($(wildcard $(xtest_sourcefile_base)),)
xtest_sourcefile_base = $(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.sources)
tests_CLEAN_FILES += $(xtest_lib_output) $(xtest_response) $(xtest_makefrag)
endif
ifndef HAVE_CS_TESTS
HAVE_CS_TESTS := $(wildcard $(test_sourcefile))
HAVE_CS_TESTS := $(wildcard $(test_sourcefile_base))
endif
HAVE_CS_XTESTS := $(wildcard $(xtest_sourcefile))
HAVE_CS_XTESTS := $(wildcard $(xtest_sourcefile_base))
endif # !NO_TEST
@@ -135,17 +147,15 @@ ifdef HAVE_CS_TESTS
test_assemblies += $(test_lib_output)
check: run-test
test-local: $(test_assemblies)
test-local: $(test_assemblies) $(test_lib_dir)/nunit-excludes.txt
run-test-local: run-test-lib
run-test-ondotnet-local: run-test-ondotnet-lib
ifdef TEST_WITH_INTERPRETER
TEST_HARNESS_EXCLUDES = -exclude=$(PLATFORM_TEST_HARNESS_EXCLUDES)$(PROFILE_TEST_HARNESS_EXCLUDES)NotWorking,NotWorkingRuntimeInterpreter,CAS
else
TEST_HARNESS_EXCLUDES = -exclude=$(PLATFORM_TEST_HARNESS_EXCLUDES)$(PROFILE_TEST_HARNESS_EXCLUDES)NotWorking,CAS
endif
TEST_HARNESS_EXCLUDES = $(PLATFORM_TEST_HARNESS_EXCLUDES) $(PROFILE_TEST_HARNESS_EXCLUDES) NotWorking CAS
TEST_HARNESS_EXCLUDES_ONDOTNET = /exclude:$(PLATFORM_TEST_HARNESS_EXCLUDES)$(PROFILE_TEST_HARNESS_EXCLUDES)NotDotNet,CAS
ifdef TEST_WITH_INTERPRETER
TEST_HARNESS_EXCLUDES += NotWorkingRuntimeInterpreter
endif
NOSHADOW_FLAG =
@@ -210,7 +220,7 @@ MKBUNDLE_EXE = $(topdir)/class/lib/$(PROFILE)/mkbundle.exe
TEST_ASSEMBLIES:=$(sort $(patsubst .//%,%,$(filter-out %.exe.static %.dll.dll %.exe.dll %bare% %plaincore% %secxml% %Facades% %ilasm%,$(filter %.dll,$(wildcard $(topdir)/class/lib/$(PROFILE)/tests/*)))))
$(MKBUNDLE_EXE): $(topdir)/tools/mkbundle/mkbundle.cs
make -C $(topdir)/tools/mkbundle
$(MAKE) -C $(topdir)/tools/mkbundle
mkbundle-all-tests:
$(Q_AOT) $(MAKE) -C $(topdir)/class do-test
@@ -229,15 +239,19 @@ endif # PLATFORM_AOT_SUFFIX
ifneq ($(wildcard $(MKBUNDLE_TEST_BIN)),)
TEST_HARNESS_EXEC=$(MKBUNDLE_TEST_BIN)
TEST_HARNESS_EXCLUDES:=$(TEST_HARNESS_EXCLUDES),StaticLinkedAotNotWorking
TEST_HARNESS_EXCLUDES:=$(TEST_HARNESS_EXCLUDES) StaticLinkedAotNotWorking
else
TEST_HARNESS_EXEC=$(TEST_RUNTIME) $(TEST_RUNTIME_FLAGS) $(TEST_COVERAGE_FLAGS) $(AOT_RUN_FLAGS) $(TEST_HARNESS)
endif
$(test_lib_dir)/nunit-excludes.txt: $(topdir)/build/tests.make | $(test_lib_dir)
@rm -f $@
@$(foreach entry,$(TEST_HARNESS_EXCLUDES),echo "$(entry)" >> $@;)
## FIXME: i18n problem in the 'sed' command below
run-test-lib: test-local test-local-aot-compile copy-nunitlite-appconfig
ok=:; \
PATH="$(TEST_RUNTIME_WRAPPERS_PATH):$(PATH)" MONO_REGISTRY_PATH="$(HOME)/.mono/registry" MONO_TESTS_IN_PROGRESS="yes" DBG_RUNTIME_ARGS="$(TEST_RUNTIME_FLAGS)" $(TEST_HARNESS_EXEC) $(test_assemblies) $(NOSHADOW_FLAG) $(TEST_HARNESS_FLAGS) $(LOCAL_TEST_HARNESS_FLAGS) $(TEST_HARNESS_EXCLUDES) $(LABELS_ARG) -format:nunit2 -result:TestResult-$(PROFILE).xml $(FIXTURE_ARG) $(TESTNAME_ARG)|| ok=false; \
PATH="$(TEST_RUNTIME_WRAPPERS_PATH):$(PATH)" MONO_REGISTRY_PATH="$(HOME)/.mono/registry" MONO_TESTS_IN_PROGRESS="yes" DBG_RUNTIME_ARGS="$(TEST_RUNTIME_FLAGS)" $(TEST_HARNESS_EXEC) $(test_assemblies) $(NOSHADOW_FLAG) $(TEST_HARNESS_FLAGS) $(LOCAL_TEST_HARNESS_FLAGS) -exclude=$(subst $(space),$(comma),$(TEST_HARNESS_EXCLUDES)) $(LABELS_ARG) -format:nunit2 -result:TestResult-$(PROFILE).xml $(FIXTURE_ARG) $(TESTNAME_ARG)|| ok=false; \
if [ ! -f "TestResult-$(PROFILE).xml" ]; then echo "<?xml version='1.0' encoding='utf-8'?><test-results failures='1' total='1' not-run='0' name='bcl-tests' date='$$(date +%F)' time='$$(date +%T)'><test-suite name='$(strip $(test_assemblies))' success='False' time='0'><results><test-case name='$(notdir $(strip $(test_assemblies))).crash' executed='True' success='False' time='0'><failure><message>The test runner didn't produce a test result XML, probably due to a crash of the runtime. Check the log for more details.</message><stack-trace></stack-trace></failure></test-case></results></test-suite></test-results>" > TestResult-$(PROFILE).xml; fi; \
$$ok
@@ -245,7 +259,7 @@ run-test-lib: test-local test-local-aot-compile copy-nunitlite-appconfig
run-test-ondotnet-lib: LOCAL_TEST_COMPILER_ONDOTNET_FLAGS:=-d:RUN_ONDOTNET
run-test-ondotnet-lib: test-local
ok=:; \
$(TEST_HARNESS) $(test_assemblies) $(NOSHADOW_FLAG) $(TEST_HARNESS_FLAGS) $(LOCAL_TEST_HARNESS_ONDOTNET_FLAGS) $(TEST_HARNESS_EXCLUDES_ONDOTNET) $(LABELS_ARG) -format:nunit2 -result:TestResult-ondotnet-$(PROFILE).xml $(FIXTURE_ARG) $(TESTNAME_ARG) || ok=false; \
$(TEST_HARNESS) $(test_assemblies) $(NOSHADOW_FLAG) $(TEST_HARNESS_FLAGS) $(LOCAL_TEST_HARNESS_ONDOTNET_FLAGS) /exclude:$(subst $(space),$(comma),$(TEST_HARNESS_EXCLUDES) NotDotNet) $(LABELS_ARG) -format:nunit2 -result:TestResult-ondotnet-$(PROFILE).xml $(FIXTURE_ARG) $(TESTNAME_ARG) || ok=false; \
$$ok
@@ -254,7 +268,7 @@ endif
TEST_FILES =
ifdef HAVE_CS_TESTS
TEST_FILES += `sed -e '/^$$/d' -e 's,^../,,' -e '/^\#.*$$/d' -et -e 's,^,Test/,' $(test_sourcefile)`
TEST_FILES += `sed -e '/^$$/d' -e 's,^../,,' -e '/^\#.*$$/d' -et -e 's,^,Test/,' $(test_sourcefile_base)`
endif
ifdef HAVE_CS_TESTS
@@ -262,23 +276,31 @@ ifdef HAVE_CS_TESTS
$(test_lib_dir):
mkdir -p $@
test_library = $(ASSEMBLY:$(ASSEMBLY_EXT)=)_test$(ASSEMBLY_EXT)
test_sourcefile = $(depsdir)/$(PROFILE_PLATFORM)_$(PROFILE)_$(test_library).sources
$(test_sourcefile): $(test_sourcefile_base) $(wildcard *_test.dll.sources) $(wildcard *_test.dll.exclude.sources) $(depsdir)/.stamp
$(GENSOURCES) --basedir:./Test --strict --platformsdir:$(topdir)/build "$@" "$(test_library)" "$(PROFILE_PLATFORM)" "$(PROFILE)"
test_response = $(depsdir)/$(PROFILE_PLATFORM)_$(PROFILE)_$(test_library).response
$(test_response): $(test_sourcefile) $(topdir)/build/tests.make $(depsdir)/.stamp
$(PLATFORM_CHANGE_SEPARATOR_CMD) <$(test_sourcefile) >$@
test_makefrag = $(depsdir)/$(PROFILE_PLATFORM)_$(PROFILE)_$(test_library).makefrag
$(test_makefrag): $(test_sourcefile) $(topdir)/build/tests.make $(depsdir)/.stamp
@echo Creating $@ ...
@sed 's,^,$(build_lib): ,' $< >$@
@if test ! -f $(test_sourcefile).makefrag; then :; else \
cat $(test_sourcefile).makefrag >> $@ ; \
echo '$@: $(test_sourcefile).makefrag' >> $@; \
echo '$(test_sourcefile).makefrag:' >> $@; fi
$(test_lib_output): $(test_assembly_dep) $(test_response) $(test_nunit_dep) $(test_lib_output).nunitlite.config | $(test_lib_dir)
$(TEST_COMPILE) $(LIBRARY_FLAGS) -target:library -out:$@ $(test_flags) $(LOCAL_TEST_COMPILER_ONDOTNET_FLAGS) @$(test_response)
test_response_preprocessed = $(test_response)_preprocessed
tests_CLEAN_FILES += $(test_sourcefile) $(test_response) $(test_makefrag)
# This handles .excludes/.sources pairs, as well as resolving the
# includes that occur in .sources files
$(test_response_preprocessed): $(test_sourcefile) $(wildcard *_test.dll.sources) $(wildcard *_test.dll.exclude.sources)
$(GENSOURCES) --basedir:./Test --strict --platformsdir:$(topdir)/build "$@" "$(test_sourcefile)" "$(test_sourcefile_excludes)"
$(test_response): $(test_response_preprocessed)
# @echo Creating $@ ...
@sed -e '/^$$/d' -e 's,^,Test/,' $(test_response_preprocessed) | $(PLATFORM_CHANGE_SEPARATOR_CMD) >$@
$(test_makefrag): $(test_response)
# @echo Creating $@ ...
@sed 's,^,$(test_lib_output): ,' $< >$@
-include $(test_makefrag)
@@ -294,11 +316,17 @@ XTEST_HARNESS_PATH := $(topdir)/../external/xunit-binaries
XTEST_HARNESS = $(XTEST_HARNESS_PATH)/xunit.console.exe
XTEST_RESULT_FILE := TestResult-$(PROFILE)-xunit.xml
XTEST_HARNESS_FLAGS := -noappdomain -noshadow -parallel none -nunit $(XTEST_RESULT_FILE)
XTEST_TRAIT := -notrait category=failing -notrait category=nonmonotests -notrait Benchmark=true -notrait category=outerloop
XTEST_NOTRAITS := category=failing category=nonmonotests Benchmark=true
ifndef OUTER_LOOP
XTEST_NOTRAITS += category=outerloop
endif
# The logic is double inverted so this actually excludes tests not intented for current platform
# best to search for `property name="category"` in the xml output to see what's going on
# https://github.com/dotnet/buildtools/blob/master/src/xunit.netcore.extensions/Discoverers/PlatformSpecificDiscoverer.cs
XTEST_TRAIT_PLATFORM := -notrait category=non$(XTEST_PLATFORM)tests
XTEST_NOTRAITS += category=non$(XTEST_PLATFORM)tests
TEST_MONO_PATH := $(TEST_MONO_PATH)$(PLATFORM_PATH_SEPARATOR)$(XTEST_HARNESS_PATH)
@@ -315,17 +343,24 @@ XTEST_COVERAGE_FLAGS = -O=-aot --profile=coverage:output=$(topdir)/class/lib/$(P
endif
check: run-xunit-test-local
xunit-test-local: $(xtest_lib_output)
xunit-test-local: $(xtest_lib_output) $(test_lib_dir)/xunit-excludes.txt $(test_lib_dir)/Xunit.NetCore.Extensions.dll $(test_lib_dir)/xunit.execution.dotnet.dll
run-xunit-test-local: run-xunit-test-lib
# cp -rf is a HACK for xunit runner to require xunit.execution.dOTNET.dll file in local folder on .net only
$(test_lib_dir)/xunit-excludes.txt: $(topdir)/build/tests.make | $(test_lib_dir)
@rm -f $@
$(foreach entry,$(XTEST_NOTRAITS),echo "$(entry)" >> $@;)
$(test_lib_dir)/Xunit.NetCore.Extensions.dll: $(topdir)/build/tests.make $(topdir)/../external/xunit-binaries/Xunit.NetCore.Extensions.dll | $(test_lib_dir)
@cp -f $(topdir)/../external/xunit-binaries/Xunit.NetCore.Extensions.dll $@
$(test_lib_dir)/xunit.execution.dotnet.dll: $(topdir)/build/tests.make $(topdir)/../external/xunit-binaries/xunit.execution.dotnet.dll | $(test_lib_dir)
@cp -f $(topdir)/../external/xunit-binaries/xunit.execution.dotnet.dll $@
run-xunit-test-lib: xunit-test-local
@cp -rf $(XTEST_HARNESS_PATH)/xunit.execution.dotnet.dll $(test_lib_dir)/xunit.execution.dotnet.dll
ok=:; \
PATH="$(TEST_RUNTIME_WRAPPERS_PATH):$(PATH)" REMOTE_EXECUTOR="$(XTEST_REMOTE_EXECUTOR_ABSPATH)" $(TEST_RUNTIME) $(TEST_RUNTIME_FLAGS) $(XTEST_COVERAGE_FLAGS) $(AOT_RUN_FLAGS) $(XTEST_HARNESS) $(xtest_lib_output) $(XTEST_HARNESS_FLAGS) $(XTEST_TRAIT) $(XTEST_TRAIT_PLATFORM) || ok=false; \
PATH="$(TEST_RUNTIME_WRAPPERS_PATH):$(PATH)" REMOTE_EXECUTOR="$(XTEST_REMOTE_EXECUTOR_ABSPATH)" $(TEST_RUNTIME) $(TEST_RUNTIME_FLAGS) $(XTEST_COVERAGE_FLAGS) $(AOT_RUN_FLAGS) $(XTEST_HARNESS) $(xtest_lib_output) $(XTEST_HARNESS_FLAGS) -notrait $(subst $(space), -notrait ,$(XTEST_NOTRAITS)) || ok=false; \
if [ -n "$$MONO_BABYSITTER_NUNIT_XML_LIST_FILE" ]; then echo "$(abspath $(XTEST_RESULT_FILE))" >> "$$MONO_BABYSITTER_NUNIT_XML_LIST_FILE"; fi; \
$$ok
@rm -f $(test_lib_dir)/xunit.execution.dotnet.dll
# Some xunit tests want to be executed in a separate process (see RemoteExecutorTestBase)
$(XTEST_REMOTE_EXECUTOR): $(topdir)/../external/corefx/src/Common/tests/System/Diagnostics/RemoteExecutorConsoleApp/RemoteExecutorConsoleApp.cs | $(test_lib_dir)
@@ -338,8 +373,8 @@ xtest_response_preprocessed = $(xtest_response)_preprocessed
# This handles .excludes/.sources pairs, as well as resolving the
# includes that occur in .sources files
$(xtest_response): $(xtest_sourcefile) $(wildcard *xtest.dll.sources) $(wildcard $(xtest_sourcefile_excludes))
$(GENSOURCES) --strict --platformsdir:$(topdir)/build "$@" "$(xtest_sourcefile)" "$(xtest_sourcefile_excludes)"
$(xtest_response): $(xtest_sourcefile_base) $(wildcard *xtest.dll.sources) $(wildcard $(xtest_sourcefile_base_excludes))
$(GENSOURCES) --strict --platformsdir:$(topdir)/build "$@" "$(xtest_sourcefile_base)" "$(xtest_sourcefile_base_excludes)"
$(xtest_makefrag): $(xtest_response)
@echo Creating $@ ...
+74 -74
View File
@@ -1,75 +1,75 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{2CFDD4F5-4B13-4FF4-A421-0361F2FC825F}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Accessibility</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="Accessibility\IAccessible.cs" />
<Compile Include="Accessibility\IAccessibleHandler.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{2CFDD4F5-4B13-4FF4-A421-0361F2FC825F}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Accessibility</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="Accessibility\IAccessible.cs" />
<Compile Include="Accessibility\IAccessibleHandler.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,131 +1,131 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{79381DFE-F13A-4A37-9A89-6640702D46E3}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Commons.Xml.Relaxng</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../mono.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<Compile Include="Commons.Xml.Relaxng.Rnc\RncParser.cs" />
</ItemGroup>
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlBuiltInValidationProvider.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlCompileContext.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlConfig.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlException.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlFilteredXmlReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlRelaxngSupport.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlSimplified.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlStructures.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidatingReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidationProvider.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidator.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlXsdSupport.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpContentType.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpNameClasses.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpObjects.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpPatterns.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\Util.cs" />
<Compile Include="Commons.Xml.Relaxng.Inference\RelaxngInference.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\RncTokenizer.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\RncWriter.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\XmlChar.cs" />
<Compile Include="Commons.Xml.Relaxng\Misc.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDatatype.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDatatypeProvider.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDefaultDatatypes.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngException.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngGrammar.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngMergedProvider.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngNameClass.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngPattern.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngPatternType.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngReader.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngValidatingReader.cs" />
<Compile Include="Commons.Xml.Relaxng\XsdDatatypeProvider.cs" />
<Compile Include="Commons.Xml\XmlDefaultReader.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
<ProjectReference Include="$(SolutionDir)\mcs\jay\jay.vcxproj">
<Name>jay</Name>
<Project>{5d485d32-3b9f-4287-ab24-c8da5b89f537}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../System.XML/System.Xml.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<EmbeddedResource Include="resources/relaxng.rng">
<LogicalName>relaxng.rng</LogicalName>
</EmbeddedResource>
</ItemGroup>
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">$(ProjectDir)\..\..\jay\jay -ct &lt; $(ProjectDir)\..\..\jay\skeleton.cs $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.jay &gt; $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.cs</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">$(ProjectDir)\..\..\jay\jay.exe -ct &lt; $(ProjectDir)\..\..\jay\skeleton.cs $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.jay &gt; $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.cs</PreBuildEvent>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{79381DFE-F13A-4A37-9A89-6640702D46E3}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Commons.Xml.Relaxng</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../mono.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<Compile Include="Commons.Xml.Relaxng.Rnc\RncParser.cs" />
</ItemGroup>
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlBuiltInValidationProvider.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlCompileContext.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlConfig.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlException.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlFilteredXmlReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlRelaxngSupport.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlSimplified.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlStructures.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidatingReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidationProvider.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidator.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlXsdSupport.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpContentType.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpNameClasses.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpObjects.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpPatterns.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\Util.cs" />
<Compile Include="Commons.Xml.Relaxng.Inference\RelaxngInference.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\RncTokenizer.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\RncWriter.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\XmlChar.cs" />
<Compile Include="Commons.Xml.Relaxng\Misc.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDatatype.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDatatypeProvider.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDefaultDatatypes.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngException.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngGrammar.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngMergedProvider.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngNameClass.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngPattern.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngPatternType.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngReader.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngValidatingReader.cs" />
<Compile Include="Commons.Xml.Relaxng\XsdDatatypeProvider.cs" />
<Compile Include="Commons.Xml\XmlDefaultReader.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
<ProjectReference Include="$(SolutionDir)\mcs\jay\jay.vcxproj">
<Name>jay</Name>
<Project>{5d485d32-3b9f-4287-ab24-c8da5b89f537}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../System.XML/System.Xml.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<EmbeddedResource Include="resources/relaxng.rng">
<LogicalName>relaxng.rng</LogicalName>
</EmbeddedResource>
</ItemGroup>
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">$(ProjectDir)\..\..\jay\jay -ct &lt; $(ProjectDir)\..\..\jay\skeleton.cs $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.jay &gt; $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.cs</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">$(ProjectDir)\..\..\jay\jay.exe -ct &lt; $(ProjectDir)\..\..\jay\skeleton.cs $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.jay &gt; $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.cs</PreBuildEvent>
</PropertyGroup>
</Project>
+78 -78
View File
@@ -1,79 +1,79 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{546B21E5-FB99-44A5-8721-2D672FBCD7FF}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>cscompmgd</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="..\..\build\common\MonoTODOAttribute.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="Microsoft.CSharp\Compiler.cs" />
<Compile Include="Microsoft.CSharp\CompilerError.cs" />
<Compile Include="Microsoft.CSharp\ErrorLevel.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{546B21E5-FB99-44A5-8721-2D672FBCD7FF}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>cscompmgd</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="..\..\build\common\MonoTODOAttribute.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="Microsoft.CSharp\Compiler.cs" />
<Compile Include="Microsoft.CSharp\CompilerError.cs" />
<Compile Include="Microsoft.CSharp\ErrorLevel.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,80 +1,80 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{FC00125C-BEA1-4A1E-A463-6070352602CD}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>CustomMarshalers</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="..\..\build\common\MonoTODOAttribute.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\EnumerableToDispatchMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\EnumeratorToEnumVariantMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\ExpandoToDispatchExMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\TypeToTypeInfoMarshaler.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{FC00125C-BEA1-4A1E-A463-6070352602CD}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>CustomMarshalers</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="..\..\build\common\MonoTODOAttribute.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\EnumerableToDispatchMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\EnumeratorToEnumVariantMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\ExpandoToDispatchExMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\TypeToTypeInfoMarshaler.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
+1 -1
View File
@@ -40,7 +40,7 @@ doc-update-recursive:
System System.Core System.ComponentModel.DataAnnotations System.Numerics System.Numerics.Vectors System.Runtime.Serialization System.Transactions System.Xml \
System.ComponentModel.Composition System.ServiceModel System.Xml.Linq System.Data System.IO.Compression.FileSystem System.Runtime.InteropServices.RuntimeInformation \
System.ServiceProcess System.Security System.Net.Http.WebRequest System.Net.Http System.ServiceProcess System.IO.Compression System.IdentityModel System.Web \
Facades/System.Drawing.Primitives System.Drawing System.Web.Services:
Facades/System.Drawing.Primitives Facades/System.Drawing.Common System.Drawing System.Web.Services:
all-local-aot:
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{FADE0AB0-B7B9-4909-B4AD-38ABE84E183A}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Microsoft.Win32.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{FADE0AB0-B7B9-4909-B4AD-38ABE84E183A}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Microsoft.Win32.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,129 +1,140 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{ECD1D1FD-CEBA-4282-989B-EE031A809F2C}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Microsoft.Win32.Registry.AccessControl</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\..\..\external\corefx\src\Microsoft.Win32.Registry.AccessControl\src\Microsoft\Win32\RegistryAclExtensions.cs" />
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{ECD1D1FD-CEBA-4282-989B-EE031A809F2C}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Microsoft.Win32.Registry.AccessControl</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\..\..\external\corefx\src\Microsoft.Win32.Registry.AccessControl\src\Microsoft\Win32\RegistryAclExtensions.cs" />
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{21811072-CC82-465D-B8D7-DA89A63024F9}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Microsoft.Win32.Registry</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{21811072-CC82-465D-B8D7-DA89A63024F9}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Microsoft.Win32.Registry</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{E21E6C69-5A3D-44A3-BCB1-CDE08786CB41}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.AppContext</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{E21E6C69-5A3D-44A3-BCB1-CDE08786CB41}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.AppContext</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,117 +1,128 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{CA080440-700C-46F4-B8F9-56D2507909D3}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Buffers</AssemblyName>
<TargetFrameworkVersion>v2.1</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../Open.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{CA080440-700C-46F4-B8F9-56D2507909D3}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Buffers</AssemblyName>
<TargetFrameworkVersion>v2.1</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../Open.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{DE0D7286-1F09-4ACC-BC43-75342349FFC1}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections.Concurrent</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{DE0D7286-1F09-4ACC-BC43-75342349FFC1}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections.Concurrent</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{42696DB3-E1FA-4C6E-BB9B-8930CD563933}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections.NonGeneric</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{42696DB3-E1FA-4C6E-BB9B-8930CD563933}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections.NonGeneric</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{C5EC0603-74A8-450A-9EE2-AEBCC964134E}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections.Specialized</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{C5EC0603-74A8-450A-9EE2-AEBCC964134E}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections.Specialized</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,129 +1,140 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{758C73D3-F04B-40BD-B55B-057F529053CA}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../System.Core/System.Core.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{758C73D3-F04B-40BD-B55B-057F529053CA}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../System.Core/System.Core.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{FDD583A9-F7AB-49E2-8B0C-B3B6C24EC3C1}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.Annotations</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System.ComponentModel.DataAnnotations/System.ComponentModel.DataAnnotations.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{FDD583A9-F7AB-49E2-8B0C-B3B6C24EC3C1}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.Annotations</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System.ComponentModel.DataAnnotations/System.ComponentModel.DataAnnotations.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{71D3A7F4-7774-4421-9DF1-FFB719F0DDA7}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.EventBasedAsync</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{71D3A7F4-7774-4421-9DF1-FFB719F0DDA7}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.EventBasedAsync</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{A2DA9A58-AE3F-41A4-8C1F-55E65244EB1B}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{A2DA9A58-AE3F-41A4-8C1F-55E65244EB1B}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -33,6 +33,7 @@
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.IComponent))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.IContainer))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.ISite))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.ISupportInitialize))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.ImmutableObjectAttribute))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.InitializationEventAttribute))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.LocalizableAttribute))]
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{4C5EAC63-07DF-41DF-8CF5-40FDA68845D9}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.TypeConverter</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{4C5EAC63-07DF-41DF-8CF5-40FDA68845D9}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.TypeConverter</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -76,6 +76,8 @@
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.UInt16Converter))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.UInt32Converter))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.UInt64Converter))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.Container))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.UriTypeConverter))]
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{BEFF31D8-EA73-46C1-BD18-DF3952122BCA}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{BEFF31D8-EA73-46C1-BD18-DF3952122BCA}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{1849D0C8-51AC-46AC-BF22-29956F733B73}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Console</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{1849D0C8-51AC-46AC-BF22-29956F733B73}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Console</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,130 +1,141 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{47044138-F46D-4336-ACD5-880B083A8B5D}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Data.Common</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../System.Data/System.Data.csproj" />
<ProjectReference Include="../../System.XML/System.Xml.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{47044138-F46D-4336-ACD5-880B083A8B5D}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Data.Common</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../System.Data/System.Data.csproj" />
<ProjectReference Include="../../System.XML/System.Xml.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,130 +1,141 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{2A1F5090-B2D3-464B-AD74-FA218D9A26A6}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Data.SqlClient</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../System.Data/System.Data.csproj" />
<ProjectReference Include="../../System.XML/System.Xml.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{2A1F5090-B2D3-464B-AD74-FA218D9A26A6}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Data.SqlClient</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../System.Data/System.Data.csproj" />
<ProjectReference Include="../../System.XML/System.Xml.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,127 +1,138 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{A62F4CA5-28A8-45E0-A94B-11D82EEAD7B5}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.Contracts</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{A62F4CA5-28A8-45E0-A94B-11D82EEAD7B5}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.Contracts</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{3A7745A6-0F61-4EF5-AB3F-2ED4F7D7DF9F}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.Debug</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{3A7745A6-0F61-4EF5-AB3F-2ED4F7D7DF9F}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.Debug</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{D2AC29C4-2668-4AB4-B686-C2AEBC1AD86B}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.FileVersionInfo</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{D2AC29C4-2668-4AB4-B686-C2AEBC1AD86B}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.FileVersionInfo</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{3EC0231A-89A5-4D4A-BD35-7AB8C42585D0}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.Process</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{3EC0231A-89A5-4D4A-BD35-7AB8C42585D0}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.Process</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{CB170322-1467-40B2-B598-E6212ECD3B89}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.StackTrace</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{CB170322-1467-40B2-B598-E6212ECD3B89}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.StackTrace</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{F27CAFD6-7370-4D77-8E57-EF879E945E5C}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.TextWriterTraceListener</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{F27CAFD6-7370-4D77-8E57-EF879E945E5C}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.TextWriterTraceListener</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{AD00F3EF-5A2B-498B-BB78-2C9CB10B25D7}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.Tools</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{AD00F3EF-5A2B-498B-BB78-2C9CB10B25D7}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.Tools</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{F74ADB74-7DED-4B5A-BC05-FF9AEC94EB59}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.TraceEvent</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{F74ADB74-7DED-4B5A-BC05-FF9AEC94EB59}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.TraceEvent</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{C2328ABA-46D0-4D37-98E3-0C17815B8EB1}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.TraceSource</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{C2328ABA-46D0-4D37-98E3-0C17815B8EB1}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.TraceSource</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,127 +1,138 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{92696156-C4BC-4F3D-BF81-9C31CC9B7055}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.Tracing</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{92696156-C4BC-4F3D-BF81-9C31CC9B7055}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Diagnostics.Tracing</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,118 +1,154 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{1D37166B-C199-47AB-B23F-A6B13F0426DC}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Drawing.Common</AssemblyName>
<TargetFrameworkVersion>v2.1</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../Open.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{1D37166B-C199-47AB-B23F-A6B13F0426DC}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Drawing.Common</AssemblyName>
<TargetFrameworkVersion>v2.1</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../Open.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\..\..\external\corefx\src\Common\src\System\Drawing\ColorTable.cs" />
<Compile Include="..\..\..\..\external\corefx\src\Common\src\System\Drawing\ColorUtil.netcoreapp21.cs" />
<Compile Include="..\..\..\..\external\corefx\src\Common\src\System\Drawing\KnownColor.cs" />
<Compile Include="..\..\..\..\external\corefx\src\Common\src\System\Drawing\KnownColorTable.cs" />
<Compile Include="..\..\..\..\external\corefx\src\Common\src\System\Numerics\Hashing\HashHelpers.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.ComponentModel.TypeConverter\src\System\Drawing\SizeFConverter.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Common\src\System\Drawing\ColorConverter.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Common\src\System\Drawing\PointConverter.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Common\src\System\Drawing\RectangleConverter.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Common\src\System\Drawing\SizeConverter.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Common\src\System\Drawing\SystemColors.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Primitives\src\System\Drawing\Color.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Primitives\src\System\Drawing\Point.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Primitives\src\System\Drawing\PointF.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Primitives\src\System\Drawing\Rectangle.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Primitives\src\System\Drawing\RectangleF.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Primitives\src\System\Drawing\Size.cs" />
<Compile Include="..\..\..\..\external\corefx\src\System.Drawing.Primitives\src\System\Drawing\SizeF.cs" />
<Compile Include="..\..\..\build\common\SR.cs" />
<Compile Include="AssemblyInfo.cs" />
<Compile Include="SR.cs" />
<Compile Include="Stubs.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -15,35 +15,10 @@ SIGN_FLAGS = /delaysign /nowarn:1616,1699
LIB_REFS = System
LIB_MCS_FLAGS = $(SIGN_FLAGS) $(EXTRA_LIB_MCS_FLAGS)
ifdef false # we'll enable this at a later point
# xammac_net_4_5 and the testing_* profiles are special, they don't build
# System.Drawing.dll or equivalent neither in Mono nor in the XM repo.
# For now we embed the types directly here.
# TODO: find a better solution.
EMBEDDED_DRAWING_DEP := $(filter xammac_net_4_5 testing_aot_full testing_aot_hybrid, $(PROFILE))
ifndef EMBEDDED_DRAWING_DEP
# profiles which build a System.Drawing.dll in the repo
REPO_DRAWING_DEP := $(filter net_4_x orbis winaot unreal testing_aot_full wasm, $(PROFILE))
ifdef REPO_DRAWING_DEP
LIB_REFS += System.Drawing
else
# When System.Drawing.dll is not built in the Mono repo but in
# the product repo like in the XI/XA case we need to pass in a reference
# to the assembly containing drawing types like Rectangle etc. from there.
# This needs to be passed in via EXTERNAL_FACADE_DRAWING_REFERENCE.
LIB_MCS_FLAGS += /r:$(EXTERNAL_FACADE_DRAWING_REFERENCE)
ifneq (,$(filter build net_4_x, $(PROFILE)))
$(error This profile shouldn't build System.Drawing.Common.dll, it already has System.Drawing.dll)
endif
endif
endif
PLATFORM_DEBUG_FLAGS =
NO_TEST = yes
include $(MCS_BUILD_DIR)/library.make
@@ -0,0 +1,8 @@
partial class SR
{
public const string InvalidColor = "Color '{0}' is not valid.";
public const string InvalidEx2BoundArgument = "Value of '{1}' is not valid for '{0}'. '{0}' should be greater than or equal to {2} and less than or equal to {3}.";
public const string PropertyValueInvalidEntry = "IDictionary parameter contains at least one entry that is not valid. Ensure all values are consistent with the object's properties.";
public const string TextParseFailedFormat = "Text \"{0}\" cannot be parsed. The expected text format is \"{1}\".";
}
@@ -7,566 +7,6 @@
// MONO: these files were copied from CoreFX (System.Drawing.Primitives/ref and System.Drawing.Common/ref)
// System.Drawing.Primitives/ref:
namespace System.Drawing
{
public readonly partial struct Color : System.IEquatable<System.Drawing.Color>
{
private readonly object _dummy;
private readonly int _dummyPrimitive;
public static readonly System.Drawing.Color Empty;
public byte A { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color AliceBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color AntiqueWhite { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Aqua { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Aquamarine { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Azure { get { throw new PlatformNotSupportedException(); } }
public byte B { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Beige { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Bisque { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Black { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color BlanchedAlmond { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Blue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color BlueViolet { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Brown { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color BurlyWood { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color CadetBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Chartreuse { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Chocolate { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Coral { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color CornflowerBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Cornsilk { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Crimson { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Cyan { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkCyan { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkGoldenrod { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkGray { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkKhaki { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkMagenta { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkOliveGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkOrange { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkOrchid { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkRed { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkSalmon { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkSeaGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkSlateBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkSlateGray { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkTurquoise { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DarkViolet { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DeepPink { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DeepSkyBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DimGray { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color DodgerBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Firebrick { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color FloralWhite { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ForestGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Fuchsia { get { throw new PlatformNotSupportedException(); } }
public byte G { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Gainsboro { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color GhostWhite { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Gold { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Goldenrod { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Gray { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Green { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color GreenYellow { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Honeydew { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color HotPink { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color IndianRed { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Indigo { get { throw new PlatformNotSupportedException(); } }
public bool IsEmpty { get { throw new PlatformNotSupportedException(); } }
public bool IsKnownColor { get { throw new PlatformNotSupportedException(); } }
public bool IsNamedColor { get { throw new PlatformNotSupportedException(); } }
public bool IsSystemColor { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Ivory { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Khaki { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Lavender { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LavenderBlush { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LawnGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LemonChiffon { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightCoral { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightCyan { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightGoldenrodYellow { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightGray { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightPink { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightSalmon { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightSeaGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightSkyBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightSlateGray { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightSteelBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LightYellow { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Lime { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color LimeGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Linen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Magenta { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Maroon { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MediumAquamarine { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MediumBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MediumOrchid { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MediumPurple { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MediumSeaGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MediumSlateBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MediumSpringGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MediumTurquoise { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MediumVioletRed { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MidnightBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MintCream { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MistyRose { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Moccasin { get { throw new PlatformNotSupportedException(); } }
public string Name { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color NavajoWhite { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Navy { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color OldLace { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Olive { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color OliveDrab { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Orange { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color OrangeRed { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Orchid { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color PaleGoldenrod { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color PaleGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color PaleTurquoise { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color PaleVioletRed { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color PapayaWhip { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color PeachPuff { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Peru { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Pink { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Plum { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color PowderBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Purple { get { throw new PlatformNotSupportedException(); } }
public byte R { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Red { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color RosyBrown { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color RoyalBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color SaddleBrown { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Salmon { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color SandyBrown { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color SeaGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color SeaShell { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Sienna { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Silver { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color SkyBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color SlateBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color SlateGray { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Snow { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color SpringGreen { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color SteelBlue { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Tan { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Teal { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Thistle { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Tomato { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Transparent { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Turquoise { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Violet { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Wheat { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color White { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color WhiteSmoke { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Yellow { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color YellowGreen { get { throw new PlatformNotSupportedException(); } }
public bool Equals(System.Drawing.Color other) { throw new PlatformNotSupportedException(); }
public override bool Equals(object obj) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Color FromArgb(int argb) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Color FromArgb(int alpha, System.Drawing.Color baseColor) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Color FromArgb(int red, int green, int blue) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Color FromArgb(int alpha, int red, int green, int blue) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Color FromKnownColor(System.Drawing.KnownColor color) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Color FromName(string name) { throw new PlatformNotSupportedException(); }
public float GetBrightness() { throw new PlatformNotSupportedException(); }
public override int GetHashCode() { throw new PlatformNotSupportedException(); }
public float GetHue() { throw new PlatformNotSupportedException(); }
public float GetSaturation() { throw new PlatformNotSupportedException(); }
public static bool operator ==(System.Drawing.Color left, System.Drawing.Color right) { throw new PlatformNotSupportedException(); }
public static bool operator !=(System.Drawing.Color left, System.Drawing.Color right) { throw new PlatformNotSupportedException(); }
public int ToArgb() { throw new PlatformNotSupportedException(); }
public System.Drawing.KnownColor ToKnownColor() { throw new PlatformNotSupportedException(); }
public override string ToString() { throw new PlatformNotSupportedException(); }
}
public enum KnownColor
{
ActiveBorder = 1,
ActiveCaption = 2,
ActiveCaptionText = 3,
AliceBlue = 28,
AntiqueWhite = 29,
AppWorkspace = 4,
Aqua = 30,
Aquamarine = 31,
Azure = 32,
Beige = 33,
Bisque = 34,
Black = 35,
BlanchedAlmond = 36,
Blue = 37,
BlueViolet = 38,
Brown = 39,
BurlyWood = 40,
ButtonFace = 168,
ButtonHighlight = 169,
ButtonShadow = 170,
CadetBlue = 41,
Chartreuse = 42,
Chocolate = 43,
Control = 5,
ControlDark = 6,
ControlDarkDark = 7,
ControlLight = 8,
ControlLightLight = 9,
ControlText = 10,
Coral = 44,
CornflowerBlue = 45,
Cornsilk = 46,
Crimson = 47,
Cyan = 48,
DarkBlue = 49,
DarkCyan = 50,
DarkGoldenrod = 51,
DarkGray = 52,
DarkGreen = 53,
DarkKhaki = 54,
DarkMagenta = 55,
DarkOliveGreen = 56,
DarkOrange = 57,
DarkOrchid = 58,
DarkRed = 59,
DarkSalmon = 60,
DarkSeaGreen = 61,
DarkSlateBlue = 62,
DarkSlateGray = 63,
DarkTurquoise = 64,
DarkViolet = 65,
DeepPink = 66,
DeepSkyBlue = 67,
Desktop = 11,
DimGray = 68,
DodgerBlue = 69,
Firebrick = 70,
FloralWhite = 71,
ForestGreen = 72,
Fuchsia = 73,
Gainsboro = 74,
GhostWhite = 75,
Gold = 76,
Goldenrod = 77,
GradientActiveCaption = 171,
GradientInactiveCaption = 172,
Gray = 78,
GrayText = 12,
Green = 79,
GreenYellow = 80,
Highlight = 13,
HighlightText = 14,
Honeydew = 81,
HotPink = 82,
HotTrack = 15,
InactiveBorder = 16,
InactiveCaption = 17,
InactiveCaptionText = 18,
IndianRed = 83,
Indigo = 84,
Info = 19,
InfoText = 20,
Ivory = 85,
Khaki = 86,
Lavender = 87,
LavenderBlush = 88,
LawnGreen = 89,
LemonChiffon = 90,
LightBlue = 91,
LightCoral = 92,
LightCyan = 93,
LightGoldenrodYellow = 94,
LightGray = 95,
LightGreen = 96,
LightPink = 97,
LightSalmon = 98,
LightSeaGreen = 99,
LightSkyBlue = 100,
LightSlateGray = 101,
LightSteelBlue = 102,
LightYellow = 103,
Lime = 104,
LimeGreen = 105,
Linen = 106,
Magenta = 107,
Maroon = 108,
MediumAquamarine = 109,
MediumBlue = 110,
MediumOrchid = 111,
MediumPurple = 112,
MediumSeaGreen = 113,
MediumSlateBlue = 114,
MediumSpringGreen = 115,
MediumTurquoise = 116,
MediumVioletRed = 117,
Menu = 21,
MenuBar = 173,
MenuHighlight = 174,
MenuText = 22,
MidnightBlue = 118,
MintCream = 119,
MistyRose = 120,
Moccasin = 121,
NavajoWhite = 122,
Navy = 123,
OldLace = 124,
Olive = 125,
OliveDrab = 126,
Orange = 127,
OrangeRed = 128,
Orchid = 129,
PaleGoldenrod = 130,
PaleGreen = 131,
PaleTurquoise = 132,
PaleVioletRed = 133,
PapayaWhip = 134,
PeachPuff = 135,
Peru = 136,
Pink = 137,
Plum = 138,
PowderBlue = 139,
Purple = 140,
Red = 141,
RosyBrown = 142,
RoyalBlue = 143,
SaddleBrown = 144,
Salmon = 145,
SandyBrown = 146,
ScrollBar = 23,
SeaGreen = 147,
SeaShell = 148,
Sienna = 149,
Silver = 150,
SkyBlue = 151,
SlateBlue = 152,
SlateGray = 153,
Snow = 154,
SpringGreen = 155,
SteelBlue = 156,
Tan = 157,
Teal = 158,
Thistle = 159,
Tomato = 160,
Transparent = 27,
Turquoise = 161,
Violet = 162,
Wheat = 163,
White = 164,
WhiteSmoke = 165,
Window = 24,
WindowFrame = 25,
WindowText = 26,
Yellow = 166,
YellowGreen = 167,
}
public partial struct Point : System.IEquatable<System.Drawing.Point>
{
private int _dummyPrimitive;
public static readonly System.Drawing.Point Empty;
public Point(System.Drawing.Size sz) { throw new PlatformNotSupportedException(); }
public Point(int dw) { throw new PlatformNotSupportedException(); }
public Point(int x, int y) { throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public bool IsEmpty { get { throw new PlatformNotSupportedException(); } }
public int X { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public int Y { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public static System.Drawing.Point Add(System.Drawing.Point pt, System.Drawing.Size sz) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Point Ceiling(System.Drawing.PointF value) { throw new PlatformNotSupportedException(); }
public bool Equals(System.Drawing.Point other) { throw new PlatformNotSupportedException(); }
public override bool Equals(object obj) { throw new PlatformNotSupportedException(); }
public override int GetHashCode() { throw new PlatformNotSupportedException(); }
public void Offset(System.Drawing.Point p) => throw new PlatformNotSupportedException();
public void Offset(int dx, int dy) => throw new PlatformNotSupportedException();
public static System.Drawing.Point operator +(System.Drawing.Point pt, System.Drawing.Size sz) { throw new PlatformNotSupportedException(); }
public static bool operator ==(System.Drawing.Point left, System.Drawing.Point right) { throw new PlatformNotSupportedException(); }
public static explicit operator System.Drawing.Size (System.Drawing.Point p) { throw new PlatformNotSupportedException(); }
public static implicit operator System.Drawing.PointF (System.Drawing.Point p) { throw new PlatformNotSupportedException(); }
public static bool operator !=(System.Drawing.Point left, System.Drawing.Point right) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Point operator -(System.Drawing.Point pt, System.Drawing.Size sz) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Point Round(System.Drawing.PointF value) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Point Subtract(System.Drawing.Point pt, System.Drawing.Size sz) { throw new PlatformNotSupportedException(); }
public override string ToString() { throw new PlatformNotSupportedException(); }
public static System.Drawing.Point Truncate(System.Drawing.PointF value) { throw new PlatformNotSupportedException(); }
}
public partial struct PointF : System.IEquatable<System.Drawing.PointF>
{
private int _dummyPrimitive;
public static readonly System.Drawing.PointF Empty;
public PointF(float x, float y) { throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public bool IsEmpty { get { throw new PlatformNotSupportedException(); } }
public float X { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public float Y { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public static System.Drawing.PointF Add(System.Drawing.PointF pt, System.Drawing.Size sz) { throw new PlatformNotSupportedException(); }
public static System.Drawing.PointF Add(System.Drawing.PointF pt, System.Drawing.SizeF sz) { throw new PlatformNotSupportedException(); }
public bool Equals(System.Drawing.PointF other) { throw new PlatformNotSupportedException(); }
public override bool Equals(object obj) { throw new PlatformNotSupportedException(); }
public override int GetHashCode() { throw new PlatformNotSupportedException(); }
public static System.Drawing.PointF operator +(System.Drawing.PointF pt, System.Drawing.Size sz) { throw new PlatformNotSupportedException(); }
public static System.Drawing.PointF operator +(System.Drawing.PointF pt, System.Drawing.SizeF sz) { throw new PlatformNotSupportedException(); }
public static bool operator ==(System.Drawing.PointF left, System.Drawing.PointF right) { throw new PlatformNotSupportedException(); }
public static bool operator !=(System.Drawing.PointF left, System.Drawing.PointF right) { throw new PlatformNotSupportedException(); }
public static System.Drawing.PointF operator -(System.Drawing.PointF pt, System.Drawing.Size sz) { throw new PlatformNotSupportedException(); }
public static System.Drawing.PointF operator -(System.Drawing.PointF pt, System.Drawing.SizeF sz) { throw new PlatformNotSupportedException(); }
public static System.Drawing.PointF Subtract(System.Drawing.PointF pt, System.Drawing.Size sz) { throw new PlatformNotSupportedException(); }
public static System.Drawing.PointF Subtract(System.Drawing.PointF pt, System.Drawing.SizeF sz) { throw new PlatformNotSupportedException(); }
public override string ToString() { throw new PlatformNotSupportedException(); }
}
public partial struct Rectangle : System.IEquatable<System.Drawing.Rectangle>
{
private int _dummyPrimitive;
public static readonly System.Drawing.Rectangle Empty;
public Rectangle(System.Drawing.Point location, System.Drawing.Size size) { throw new PlatformNotSupportedException(); }
public Rectangle(int x, int y, int width, int height) { throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public int Bottom { get { throw new PlatformNotSupportedException(); } }
public int Height { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public bool IsEmpty { get { throw new PlatformNotSupportedException(); } }
[System.ComponentModel.BrowsableAttribute(false)]
public int Left { get { throw new PlatformNotSupportedException(); } }
[System.ComponentModel.BrowsableAttribute(false)]
public System.Drawing.Point Location { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public int Right { get { throw new PlatformNotSupportedException(); } }
[System.ComponentModel.BrowsableAttribute(false)]
public System.Drawing.Size Size { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public int Top { get { throw new PlatformNotSupportedException(); } }
public int Width { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public int X { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public int Y { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public static System.Drawing.Rectangle Ceiling(System.Drawing.RectangleF value) { throw new PlatformNotSupportedException(); }
public bool Contains(System.Drawing.Point pt) { throw new PlatformNotSupportedException(); }
public bool Contains(System.Drawing.Rectangle rect) { throw new PlatformNotSupportedException(); }
public bool Contains(int x, int y) { throw new PlatformNotSupportedException(); }
public bool Equals(System.Drawing.Rectangle other) { throw new PlatformNotSupportedException(); }
public override bool Equals(object obj) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Rectangle FromLTRB(int left, int top, int right, int bottom) { throw new PlatformNotSupportedException(); }
public override int GetHashCode() { throw new PlatformNotSupportedException(); }
public static System.Drawing.Rectangle Inflate(System.Drawing.Rectangle rect, int x, int y) { throw new PlatformNotSupportedException(); }
public void Inflate(System.Drawing.Size size) => throw new PlatformNotSupportedException();
public void Inflate(int width, int height) => throw new PlatformNotSupportedException();
public void Intersect(System.Drawing.Rectangle rect) => throw new PlatformNotSupportedException();
public static System.Drawing.Rectangle Intersect(System.Drawing.Rectangle a, System.Drawing.Rectangle b) { throw new PlatformNotSupportedException(); }
public bool IntersectsWith(System.Drawing.Rectangle rect) { throw new PlatformNotSupportedException(); }
public void Offset(System.Drawing.Point pos) => throw new PlatformNotSupportedException();
public void Offset(int x, int y) => throw new PlatformNotSupportedException();
public static bool operator ==(System.Drawing.Rectangle left, System.Drawing.Rectangle right) { throw new PlatformNotSupportedException(); }
public static bool operator !=(System.Drawing.Rectangle left, System.Drawing.Rectangle right) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Rectangle Round(System.Drawing.RectangleF value) { throw new PlatformNotSupportedException(); }
public override string ToString() { throw new PlatformNotSupportedException(); }
public static System.Drawing.Rectangle Truncate(System.Drawing.RectangleF value) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Rectangle Union(System.Drawing.Rectangle a, System.Drawing.Rectangle b) { throw new PlatformNotSupportedException(); }
}
public partial struct RectangleF : System.IEquatable<System.Drawing.RectangleF>
{
private int _dummyPrimitive;
public static readonly System.Drawing.RectangleF Empty;
public RectangleF(System.Drawing.PointF location, System.Drawing.SizeF size) { throw new PlatformNotSupportedException(); }
public RectangleF(float x, float y, float width, float height) { throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public float Bottom { get { throw new PlatformNotSupportedException(); } }
public float Height { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public bool IsEmpty { get { throw new PlatformNotSupportedException(); } }
[System.ComponentModel.BrowsableAttribute(false)]
public float Left { get { throw new PlatformNotSupportedException(); } }
[System.ComponentModel.BrowsableAttribute(false)]
public System.Drawing.PointF Location { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public float Right { get { throw new PlatformNotSupportedException(); } }
[System.ComponentModel.BrowsableAttribute(false)]
public System.Drawing.SizeF Size { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public float Top { get { throw new PlatformNotSupportedException(); } }
public float Width { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public float X { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public float Y { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public bool Contains(System.Drawing.PointF pt) { throw new PlatformNotSupportedException(); }
public bool Contains(System.Drawing.RectangleF rect) { throw new PlatformNotSupportedException(); }
public bool Contains(float x, float y) { throw new PlatformNotSupportedException(); }
public bool Equals(System.Drawing.RectangleF other) { throw new PlatformNotSupportedException(); }
public override bool Equals(object obj) { throw new PlatformNotSupportedException(); }
public static System.Drawing.RectangleF FromLTRB(float left, float top, float right, float bottom) { throw new PlatformNotSupportedException(); }
public override int GetHashCode() { throw new PlatformNotSupportedException(); }
public static System.Drawing.RectangleF Inflate(System.Drawing.RectangleF rect, float x, float y) { throw new PlatformNotSupportedException(); }
public void Inflate(System.Drawing.SizeF size) => throw new PlatformNotSupportedException();
public void Inflate(float x, float y) => throw new PlatformNotSupportedException();
public void Intersect(System.Drawing.RectangleF rect) => throw new PlatformNotSupportedException();
public static System.Drawing.RectangleF Intersect(System.Drawing.RectangleF a, System.Drawing.RectangleF b) { throw new PlatformNotSupportedException(); }
public bool IntersectsWith(System.Drawing.RectangleF rect) { throw new PlatformNotSupportedException(); }
public void Offset(System.Drawing.PointF pos) => throw new PlatformNotSupportedException();
public void Offset(float x, float y) => throw new PlatformNotSupportedException();
public static bool operator ==(System.Drawing.RectangleF left, System.Drawing.RectangleF right) { throw new PlatformNotSupportedException(); }
public static implicit operator System.Drawing.RectangleF (System.Drawing.Rectangle r) { throw new PlatformNotSupportedException(); }
public static bool operator !=(System.Drawing.RectangleF left, System.Drawing.RectangleF right) { throw new PlatformNotSupportedException(); }
public override string ToString() { throw new PlatformNotSupportedException(); }
public static System.Drawing.RectangleF Union(System.Drawing.RectangleF a, System.Drawing.RectangleF b) { throw new PlatformNotSupportedException(); }
}
public partial struct Size : System.IEquatable<System.Drawing.Size>
{
private int _dummyPrimitive;
public static readonly System.Drawing.Size Empty;
public Size(System.Drawing.Point pt) { throw new PlatformNotSupportedException(); }
public Size(int width, int height) { throw new PlatformNotSupportedException(); }
public int Height { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public bool IsEmpty { get { throw new PlatformNotSupportedException(); } }
public int Width { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public static System.Drawing.Size Add(System.Drawing.Size sz1, System.Drawing.Size sz2) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Size Ceiling(System.Drawing.SizeF value) { throw new PlatformNotSupportedException(); }
public bool Equals(System.Drawing.Size other) { throw new PlatformNotSupportedException(); }
public override bool Equals(object obj) { throw new PlatformNotSupportedException(); }
public override int GetHashCode() { throw new PlatformNotSupportedException(); }
public static System.Drawing.Size operator +(System.Drawing.Size sz1, System.Drawing.Size sz2) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Size operator /(System.Drawing.Size left, int right) { throw new PlatformNotSupportedException(); }
public static System.Drawing.SizeF operator /(System.Drawing.Size left, float right) { throw new PlatformNotSupportedException(); }
public static bool operator ==(System.Drawing.Size sz1, System.Drawing.Size sz2) { throw new PlatformNotSupportedException(); }
public static explicit operator System.Drawing.Point (System.Drawing.Size size) { throw new PlatformNotSupportedException(); }
public static implicit operator System.Drawing.SizeF (System.Drawing.Size p) { throw new PlatformNotSupportedException(); }
public static bool operator !=(System.Drawing.Size sz1, System.Drawing.Size sz2) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Size operator *(System.Drawing.Size left, int right) { throw new PlatformNotSupportedException(); }
public static System.Drawing.SizeF operator *(System.Drawing.Size left, float right) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Size operator *(int left, System.Drawing.Size right) { throw new PlatformNotSupportedException(); }
public static System.Drawing.SizeF operator *(float left, System.Drawing.Size right) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Size operator -(System.Drawing.Size sz1, System.Drawing.Size sz2) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Size Round(System.Drawing.SizeF value) { throw new PlatformNotSupportedException(); }
public static System.Drawing.Size Subtract(System.Drawing.Size sz1, System.Drawing.Size sz2) { throw new PlatformNotSupportedException(); }
public override string ToString() { throw new PlatformNotSupportedException(); }
public static System.Drawing.Size Truncate(System.Drawing.SizeF value) { throw new PlatformNotSupportedException(); }
}
public partial struct SizeF : System.IEquatable<System.Drawing.SizeF>
{
private int _dummyPrimitive;
public static readonly System.Drawing.SizeF Empty;
public SizeF(System.Drawing.PointF pt) { throw new PlatformNotSupportedException(); }
public SizeF(System.Drawing.SizeF size) { throw new PlatformNotSupportedException(); }
public SizeF(float width, float height) { throw new PlatformNotSupportedException(); }
public float Height { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
[System.ComponentModel.BrowsableAttribute(false)]
public bool IsEmpty { get { throw new PlatformNotSupportedException(); } }
public float Width { get { throw new PlatformNotSupportedException(); } set => throw new PlatformNotSupportedException(); }
public static System.Drawing.SizeF Add(System.Drawing.SizeF sz1, System.Drawing.SizeF sz2) { throw new PlatformNotSupportedException(); }
public bool Equals(System.Drawing.SizeF other) { throw new PlatformNotSupportedException(); }
public override bool Equals(object obj) { throw new PlatformNotSupportedException(); }
public override int GetHashCode() { throw new PlatformNotSupportedException(); }
public static System.Drawing.SizeF operator +(System.Drawing.SizeF sz1, System.Drawing.SizeF sz2) { throw new PlatformNotSupportedException(); }
public static System.Drawing.SizeF operator /(System.Drawing.SizeF left, float right) { throw new PlatformNotSupportedException(); }
public static bool operator ==(System.Drawing.SizeF sz1, System.Drawing.SizeF sz2) { throw new PlatformNotSupportedException(); }
public static explicit operator System.Drawing.PointF (System.Drawing.SizeF size) { throw new PlatformNotSupportedException(); }
public static bool operator !=(System.Drawing.SizeF sz1, System.Drawing.SizeF sz2) { throw new PlatformNotSupportedException(); }
public static System.Drawing.SizeF operator *(System.Drawing.SizeF left, float right) { throw new PlatformNotSupportedException(); }
public static System.Drawing.SizeF operator *(float left, System.Drawing.SizeF right) { throw new PlatformNotSupportedException(); }
public static System.Drawing.SizeF operator -(System.Drawing.SizeF sz1, System.Drawing.SizeF sz2) { throw new PlatformNotSupportedException(); }
public static System.Drawing.SizeF Subtract(System.Drawing.SizeF sz1, System.Drawing.SizeF sz2) { throw new PlatformNotSupportedException(); }
public System.Drawing.PointF ToPointF() { throw new PlatformNotSupportedException(); }
public System.Drawing.Size ToSize() { throw new PlatformNotSupportedException(); }
public override string ToString() { throw new PlatformNotSupportedException(); }
}
}
// System.Drawing.Common/ref:
namespace System.Drawing
{
@@ -1690,42 +1130,7 @@ namespace System.Drawing
public static System.Drawing.Brush WindowText { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Brush FromSystemColor(System.Drawing.Color c) { throw new PlatformNotSupportedException(); }
}
public static partial class SystemColors
{
public static System.Drawing.Color ActiveBorder { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ActiveCaption { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ActiveCaptionText { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color AppWorkspace { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ButtonFace { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ButtonHighlight { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ButtonShadow { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Control { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ControlDark { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ControlDarkDark { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ControlLight { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ControlLightLight { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ControlText { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Desktop { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color GradientActiveCaption { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color GradientInactiveCaption { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color GrayText { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Highlight { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color HighlightText { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color HotTrack { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color InactiveBorder { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color InactiveCaption { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color InactiveCaptionText { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Info { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color InfoText { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Menu { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MenuBar { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MenuHighlight { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color MenuText { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color ScrollBar { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color Window { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color WindowFrame { get { throw new PlatformNotSupportedException(); } }
public static System.Drawing.Color WindowText { get { throw new PlatformNotSupportedException(); } }
}
public static partial class SystemFonts
{
public static System.Drawing.Font CaptionFont { get { throw new PlatformNotSupportedException(); } }
@@ -3564,4 +2969,4 @@ namespace System.Drawing.Text
SingleBitPerPixelGridFit = 1,
SystemDefault = 0,
}
}
}
@@ -1,2 +1,22 @@
TypeForwarders.cs
AssemblyInfo.cs
Stubs.cs
SR.cs
../../../build/common/SR.cs
../../../../external/corefx/src/Common/src/System/Drawing/ColorTable.cs
../../../../external/corefx/src/Common/src/System/Drawing/ColorUtil.netcoreapp21.cs
../../../../external/corefx/src/Common/src/System/Drawing/KnownColor.cs
../../../../external/corefx/src/Common/src/System/Drawing/KnownColorTable.cs
../../../../external/corefx/src/Common/src/System/Numerics/Hashing/HashHelpers.cs
../../../../external/corefx/src/System.ComponentModel.TypeConverter/src/System/Drawing/SizeFConverter.cs
../../../../external/corefx/src/System.Drawing.Common/src/System/Drawing/ColorConverter.cs
../../../../external/corefx/src/System.Drawing.Common/src/System/Drawing/PointConverter.cs
../../../../external/corefx/src/System.Drawing.Common/src/System/Drawing/RectangleConverter.cs
../../../../external/corefx/src/System.Drawing.Common/src/System/Drawing/SizeConverter.cs
../../../../external/corefx/src/System.Drawing.Common/src/System/Drawing/SystemColors.cs
../../../../external/corefx/src/System.Drawing.Primitives/src/System/Drawing/Color.cs
../../../../external/corefx/src/System.Drawing.Primitives/src/System/Drawing/Point.cs
../../../../external/corefx/src/System.Drawing.Primitives/src/System/Drawing/PointF.cs
../../../../external/corefx/src/System.Drawing.Primitives/src/System/Drawing/Rectangle.cs
../../../../external/corefx/src/System.Drawing.Primitives/src/System/Drawing/RectangleF.cs
../../../../external/corefx/src/System.Drawing.Primitives/src/System/Drawing/Size.cs
../../../../external/corefx/src/System.Drawing.Primitives/src/System/Drawing/SizeF.cs
@@ -1,218 +1,174 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Drawing.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN;NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!--Per-profile files-->
<Choose>
<When Condition="'$(Platform)' == 'xammac'">
<ItemGroup />
</When>
<When Condition="'$(Platform)' == 'winaot'">
<ItemGroup />
</When>
<When Condition="'$(Platform)' == 'wasm'">
<ItemGroup />
</When>
<When Condition="'$(Platform)' == 'unreal'">
<ItemGroup />
</When>
<When Condition="'$(Platform)' == 'orbis'">
<ItemGroup />
</When>
<When Condition="'$(Platform)' == 'net_4_x'">
<ItemGroup />
</When>
<When Condition="'$(Platform)' == 'monotouch_watch'">
<ItemGroup />
</When>
<When Condition="'$(Platform)' == 'monotouch_tv'">
<ItemGroup />
</When>
<When Condition="'$(Platform)' == 'monotouch'">
<ItemGroup />
</When>
<When Condition="'$(Platform)' == 'monodroid'">
<ItemGroup />
</When>
</Choose>
<!--End of per-profile files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../../System.Drawing/System.Drawing.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monodroid' ">
<Reference Include="./../../../../external/binary-reference-assemblies/build/monodroid/Mono.Android.dll">
<SpecificVersion>False</SpecificVersion>
<HintPath>./../../../../external/binary-reference-assemblies/build/monodroid/Mono.Android.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monotouch' ">
<Reference Include="./../../../../external/binary-reference-assemblies/build/monotouch/Xamarin.iOS.dll">
<SpecificVersion>False</SpecificVersion>
<HintPath>./../../../../external/binary-reference-assemblies/build/monotouch/Xamarin.iOS.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<Reference Include="./../../../../external/binary-reference-assemblies/build/monotouch/Xamarin.WatchOS.dll">
<SpecificVersion>False</SpecificVersion>
<HintPath>./../../../../external/binary-reference-assemblies/build/monotouch/Xamarin.WatchOS.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<Reference Include="./../../../../external/binary-reference-assemblies/build/monotouch/Xamarin.TVOS.dll">
<SpecificVersion>False</SpecificVersion>
<HintPath>./../../../../external/binary-reference-assemblies/build/monotouch/Xamarin.TVOS.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
<ProjectReference Include="../../System.Drawing/System.Drawing.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'winaot' ">
<ProjectReference Include="../../System.Drawing/System.Drawing.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'xammac' ">
<Reference Include="./../../../../external/binary-reference-assemblies/build/monotouch/Xamarin.Mac.dll">
<SpecificVersion>False</SpecificVersion>
<HintPath>./../../../../external/binary-reference-assemblies/build/monotouch/Xamarin.Mac.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'orbis' ">
<ProjectReference Include="../../System.Drawing/System.Drawing.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'unreal' ">
<ProjectReference Include="../../System.Drawing/System.Drawing.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'wasm' ">
<ProjectReference Include="../../System.Drawing/System.Drawing.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Drawing.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../../System.Drawing/System.Drawing.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monodroid' ">
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monotouch' ">
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'winaot' ">
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'xammac' ">
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'orbis' ">
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'unreal' ">
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'wasm' ">
<ProjectReference Include="../System.Drawing.Common/Facades_System.Drawing.Common.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
Loaded 100 of 4433 files, more files were not shown because too many files have changed in this diff. Show more