--- /dev/null
+// #define ARCH_32
+#define NINT_JIT_OPTIMIZED
+
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+
+public class BuiltinTests {
+ static int test_0_nint_ctor ()
+ {
+ var x = new nint (10);
+ var y = new nint (x);
+ var z = new nint (new nint (20));
+ if ((int)x != 10)
+ return 1;
+ if ((int)y != 10)
+ return 2;
+ if ((int)z != 20)
+ return 3;
+ return 0;
+ }
+
+ static int test_0_nint_casts ()
+ {
+ var x = (nint)10;
+ var y = (nint)20L;
+
+ if ((int)x != 10)
+ return 1;
+ if ((long)x != 10L)
+ return 2;
+ if ((int)y != 20)
+ return 3;
+ if ((long)y != 20L)
+ return 4;
+ return 0;
+ }
+
+ static int test_0_nint_plus ()
+ {
+ var x = (nint)10;
+ var z = +x;
+ if ((int)z != 10)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_neg ()
+ {
+ var x = (nint)10;
+ var z = -x;
+ if ((int)z != -10)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_comp ()
+ {
+ var x = (nint)10;
+ var z = ~x;
+ if ((int)z != ~10)
+ return 1;
+ return 0;
+ }
+
+#if FALSE
+ static int test_0_nint_inc ()
+ {
+ var x = (nint)10;
+ ++x;
+ if ((int)x != 11)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_dec ()
+ {
+ var x = (nint)10;
+ --x;
+ if ((int)x != 9)
+ return 1;
+ return 0;
+ }
+#endif
+
+ static int test_0_nint_add ()
+ {
+ var x = (nint)10;
+ var y = (nint)20;
+ var z = x + y;
+ if ((int)z != 30)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_sub ()
+ {
+ var x = (nint)10;
+ var y = (nint)20;
+ var z = x - y;
+ if ((int)z != -10)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_mul ()
+ {
+ var x = (nint)10;
+ var y = (nint)20;
+ var z = x * y;
+ if ((int)z != 200)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_div ()
+ {
+ var x = (nint)30;
+ var y = (nint)3;
+ var z = x / y;
+ if ((int)z != 10)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_rem ()
+ {
+ var x = (nint)22;
+ var y = (nint)10;
+ var z = x % y;
+ if ((int)z != 2)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_and ()
+ {
+ var x = (nint)0x30;
+ var y = (nint)0x11;
+ var z = x & y;
+ if ((int)z != 0x10)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_or ()
+ {
+ var x = (nint)0x0F;
+ var y = (nint)0xF0;
+ var z = x | y;
+ if ((int)z != 0xFF)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_xor ()
+ {
+ var x = (nint)0xFF;
+ var y = (nint)0xF0;
+ var z = x ^ y;
+ if ((int)z != 0x0F)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_shl ()
+ {
+ var x = (nint)10;
+ var z = x << 2;
+ if ((int)z != 40)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_shr ()
+ {
+ var x = (nint)10;
+ var z = x >> 2;
+ if ((int)z != 2)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nint_cmp_same_val ()
+ {
+ var x = (nint)10;
+ var y = (nint)10;
+ if (!(x == y))
+ return 1;
+ if (x != y)
+ return 2;
+ if (x < y)
+ return 3;
+ if (x > y)
+ return 4;
+ if (!(x <= y))
+ return 5;
+ if (!(x >= y))
+ return 6;
+ return 0;
+ }
+
+ static int test_0_nint_cmp_small_val ()
+ {
+ var x = (nint)5;
+ var y = (nint)10;
+ if (x == y)
+ return 1;
+ if (!(x != y))
+ return 2;
+ if (!(x < y))
+ return 3;
+ if (x > y)
+ return 4;
+ if (!(x <= y))
+ return 5;
+ if (x >= y)
+ return 6;
+ return 0;
+ }
+
+ static int test_0_nint_cmp_large_val ()
+ {
+ var x = (nint)20;
+ var y = (nint)10;
+ if (x == y)
+ return 1;
+ if (!(x != y))
+ return 2;
+ if (x < y)
+ return 3;
+ if (!(x > y))
+ return 4;
+ if (x <= y)
+ return 1;
+ if (!(x >= y))
+ return 1;
+ return 0;
+ }
+
+ // static int test_0_nint_call_boxed_equals ()
+ // {
+ // object x = new nint (10);
+ // object y = new nint (10);
+ // if (!x.Equals (y))
+ // return 1;
+ // return 0;
+ // }
+
+ static int test_0_nint_call_boxed_funs ()
+ {
+ object x = new nint (10);
+ object y = new nint (10);
+ if (x.GetHashCode () == 0)
+ return 2;
+ if (x.ToString () != "10")
+ return 3;
+ return 0;
+ }
+
+ public int test_0_nint_unboxed_member_calls ()
+ {
+ var x = (nint)10;
+#if FALSE
+ if (!x.Equals (x))
+ return 1;
+#endif
+ if (x != nint.Parse ("10"))
+ return 2;
+ return 0;
+ }
+
+ static int test_0_nuint_ctor ()
+ {
+ var x = new nuint (10u);
+ var y = new nuint (x);
+ var z = new nuint (new nuint (20u));
+ if ((uint)x != 10)
+ return 1;
+ if ((uint)y != 10)
+ return 2;
+ if ((uint)z != 20)
+ return 3;
+ return 0;
+ }
+
+ static int test_0_nuint_casts ()
+ {
+ var x = (nuint)10;
+ var y = (nuint)20L;
+
+ if ((uint)x != 10)
+ return 1;
+ if ((ulong)x != 10L)
+ return 2;
+ if ((uint)y != 20)
+ return 3;
+ if ((ulong)y != 20L)
+ return 4;
+ return 0;
+ }
+
+ static int test_0_nuint_plus ()
+ {
+ var x = (nuint)10;
+ var z = +x;
+ if ((uint)z != 10)
+ return 1;
+ return 0;
+ }
+
+ // static int test_0_nuint_neg ()
+ // {
+ // var x = (nuint)10;
+ // var z = -x;
+ // if ((uint)z != -10)
+ // return 1;
+ // return 0;
+ // }
+
+ static int test_0_nuint_comp ()
+ {
+ var x = (nuint)10;
+ var z = ~x;
+ if ((uint)z != ~10u)
+ return 1;
+ return 0;
+ }
+
+#if FALSE
+ static int test_0_nuint_inc ()
+ {
+ var x = (nuint)10;
+ ++x;
+ if ((uint)x != 11)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_dec ()
+ {
+ var x = (nuint)10;
+ --x;
+ if ((uint)x != 9)
+ return 1;
+ return 0;
+ }
+#endif
+
+ static int test_0_nuint_add ()
+ {
+ var x = (nuint)10;
+ var y = (nuint)20;
+ var z = x + y;
+ if ((uint)z != 30)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_sub ()
+ {
+ var x = (nuint)20;
+ var y = (nuint)5;
+ var z = x - y;
+ if ((uint)z != 15)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_mul ()
+ {
+ var x = (nuint)10;
+ var y = (nuint)20;
+ var z = x * y;
+ if ((uint)z != 200)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_div ()
+ {
+ var x = (nuint)30;
+ var y = (nuint)3;
+ var z = x / y;
+ if ((uint)z != 10)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_rem ()
+ {
+ var x = (nuint)22;
+ var y = (nuint)10;
+ var z = x % y;
+ if ((uint)z != 2)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_and ()
+ {
+ var x = (nuint)0x30;
+ var y = (nuint)0x11;
+ var z = x & y;
+ if ((uint)z != 0x10)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_or ()
+ {
+ var x = (nuint)0x0F;
+ var y = (nuint)0xF0;
+ var z = x | y;
+ if ((uint)z != 0xFF)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_xor ()
+ {
+ var x = (nuint)0xFF;
+ var y = (nuint)0xF0;
+ var z = x ^ y;
+ if ((uint)z != 0x0F)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_shl ()
+ {
+ var x = (nuint)10;
+ var z = x << 2;
+ if ((uint)z != 40)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_shr ()
+ {
+ var x = (nuint)10;
+ var z = x >> 2;
+ if ((uint)z != 2)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nuint_cmp_same_val ()
+ {
+ var x = (nuint)10;
+ var y = (nuint)10;
+ if (!(x == y))
+ return 1;
+ if (x != y)
+ return 2;
+ if (x < y)
+ return 3;
+ if (x > y)
+ return 4;
+ if (!(x <= y))
+ return 5;
+ if (!(x >= y))
+ return 6;
+ return 0;
+ }
+
+ static int test_0_nuint_cmp_small_val ()
+ {
+ var x = (nuint)5;
+ var y = (nuint)10;
+ if (x == y)
+ return 1;
+ if (!(x != y))
+ return 2;
+ if (!(x < y))
+ return 3;
+ if (x > y)
+ return 4;
+ if (!(x <= y))
+ return 5;
+ if (x >= y)
+ return 6;
+ return 0;
+ }
+
+ static int test_0_nuint_cmp_large_val ()
+ {
+ var x = (nuint)20;
+ var y = (nuint)10;
+ if (x == y)
+ return 1;
+ if (!(x != y))
+ return 2;
+ if (x < y)
+ return 3;
+ if (!(x > y))
+ return 4;
+ if (x <= y)
+ return 1;
+ if (!(x >= y))
+ return 1;
+ return 0;
+ }
+
+ // static int test_0_nuint_call_boxed_equals ()
+ // {
+ // object x = new nuint (10);
+ // object y = new nuint (10);
+ // if (!x.Equals (y))
+ // return 1;
+ // return 0;
+ // }
+
+ static int test_0_nuint_call_boxed_funs ()
+ {
+ object x = new nuint (10u);
+ object y = new nuint (10u);
+ if (x.GetHashCode () == 0)
+ return 2;
+ if (x.ToString () != "10")
+ return 3;
+ return 0;
+ }
+
+ public int test_0_nuint_unboxed_member_calls ()
+ {
+ var x = (nuint)10;
+#if FALSE
+ if (!x.Equals (x))
+ return 1;
+#endif
+ if (x != nuint.Parse ("10"))
+ return 2;
+ return 0;
+ }
+
+ static int test_0_nfloat_ctor ()
+ {
+ var x = new nfloat (10.0f);
+ var y = new nfloat (x);
+ var z = new nfloat (new nfloat (20f));
+ if ((float)x != 10f)
+ return 1;
+ if ((float)y != 10f)
+ return 2;
+ if ((float)z != 20f)
+ return 3;
+ return 0;
+ }
+
+ static int test_0_nfloat_casts ()
+ {
+ var x = (nfloat)10f;
+
+ if ((float)x != 10f)
+ return 1;
+ if ((double)x != 10)
+ return 2;
+#if FALSE
+ var y = (nfloat)20;
+ if ((float)y != 20f)
+ return 3;
+ if ((double)y != 20)
+ return 4;
+#endif
+ return 0;
+ }
+
+ static int test_0_nfloat_plus ()
+ {
+ var x = (nfloat)10f;
+ var z = +x;
+ if ((float)z != 10f)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nfloat_neg ()
+ {
+ var x = (nfloat)10f;
+ var z = -x;
+ if ((float)z != -10f)
+ return 1;
+ return 0;
+ }
+
+#if FALSE
+ static int test_0_nfloat_inc ()
+ {
+ var x = (nfloat)10f;
+ ++x;
+ if ((float)x != 11f) {
+ Console.WriteLine ((float)x);
+ return 1;
+ }
+ return 0;
+ }
+
+ static int test_0_nfloat_dec ()
+ {
+ var x = (nfloat)10f;
+ --x;
+ if ((float)x != 9f) {
+ Console.WriteLine ((float)x);
+ return 1;
+ }
+ return 0;
+ }
+#endif
+
+ static int test_0_nfloat_add ()
+ {
+ var x = (nfloat)10f;
+ var y = (nfloat)20f;
+ var z = x + y;
+ if ((float)z != 30f)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nfloat_sub ()
+ {
+ var x = (nfloat)10f;
+ var y = (nfloat)20f;
+ var z = x - y;
+ if ((float)z != -10f)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nfloat_mul ()
+ {
+ var x = (nfloat)10f;
+ var y = (nfloat)20f;
+ var z = x * y;
+ if ((float)z != 200f)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nfloat_div ()
+ {
+ var x = (nfloat)30f;
+ var y = (nfloat)3f;
+ var z = x / y;
+ if ((float)z != 10f)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nfloat_rem ()
+ {
+ var x = (nfloat)22f;
+ var y = (nfloat)10f;
+ var z = x % y;
+ if ((float)z != 2f)
+ return 1;
+ return 0;
+ }
+
+ static int test_0_nfloat_cmp_same_val ()
+ {
+ var x = (nfloat)10f;
+ var y = (nfloat)10f;
+ if (!(x == y))
+ return 1;
+ if (x != y)
+ return 2;
+ if (x < y)
+ return 3;
+ if (x > y)
+ return 4;
+ if (!(x <= y))
+ return 5;
+ if (!(x >= y))
+ return 6;
+ return 0;
+ }
+
+ static int test_0_nfloat_cmp_small_val ()
+ {
+ var x = (nfloat)5f;
+ var y = (nfloat)10f;
+ if (x == y)
+ return 1;
+ if (!(x != y))
+ return 2;
+ if (!(x < y))
+ return 3;
+ if (x > y)
+ return 4;
+ if (!(x <= y))
+ return 5;
+ if (x >= y)
+ return 6;
+ return 0;
+ }
+
+ static int test_0_nfloat_cmp_large_val ()
+ {
+ var x = (nfloat)20f;
+ var y = (nfloat)10f;
+ if (x == y)
+ return 1;
+ if (!(x != y))
+ return 2;
+ if (x < y)
+ return 3;
+ if (!(x > y))
+ return 4;
+ if (x <= y)
+ return 1;
+ if (!(x >= y))
+ return 1;
+ return 0;
+ }
+
+ /* fails on arm64 */
+#if FALSE
+ static int test_0_nfloat_cmp_left_nan ()
+ {
+ var x = (nfloat)float.NaN;
+ var y = (nfloat)10f;
+ if (x == y)
+ return 1;
+ if (!(x != y))
+ return 2;
+ if (x < y)
+ return 3;
+ if (x > y)
+ return 4;
+ if (x <= y)
+ return 1;
+ if (x >= y)
+ return 1;
+ return 0;
+ }
+
+
+ static int test_0_nfloat_cmp_right_nan ()
+ {
+ var x = (nfloat)10f;
+ var y = (nfloat)float.NaN;
+ if (x == y)
+ return 1;
+ if (!(x != y))
+ return 2;
+ if (x < y)
+ return 3;
+ if (x > y)
+ return 4;
+ if (x <= y)
+ return 1;
+ if (x >= y)
+ return 1;
+ return 0;
+ }
+#endif
+
+ // static int test_0_nfloat_call_boxed_equals ()
+ // {
+ // object x = new nfloat (10f);
+ // object y = new nfloat (10f);
+ // if (!x.Equals (y))
+ // return 1;
+ // return 0;
+ // }
+
+ static int test_0_nfloat_call_boxed_funs ()
+ {
+ object x = new nfloat (10f);
+ object y = new nfloat (10f);
+ if (x.GetHashCode () == 0)
+ return 2;
+ if (x.ToString () != "10")
+ return 3;
+ return 0;
+ }
+
+ public int test_0_nfloat_unboxed_member_calls ()
+ {
+ var x = (nfloat)10f;
+#if FALSE
+ if (!x.Equals (x))
+ return 1;
+#endif
+ if (x != nfloat.Parse ("10"))
+ return 2;
+ return 0;
+ }
+
+ public static int Main (String[] args) {
+ return TestDriver.RunTests (typeof (BuiltinTests), args);
+ }
+}
+
+
+// !!! WARNING - GENERATED CODE - DO NOT EDIT !!!
+//
+// Generated by NativeTypes.tt, a T4 template.
+//
+// NativeTypes.cs: basic types with 32 or 64 bit sizes:
+//
+// - nint
+// - nuint
+// - nfloat
+//
+// Authors:
+// Aaron Bockover <abock@xamarin.com>
+//
+// Copyright 2013 Xamarin, Inc. All rights reserved.
+//
+
+namespace System
+{
+ [Serializable]
+ [DebuggerDisplay ("{v,nq}")]
+ public unsafe struct nint : IFormattable, IConvertible, IComparable, IComparable<nint>, IEquatable <nint>
+ {
+ internal nint (nint v) { this.v = v.v; }
+ public nint (Int32 v) { this.v = v; }
+
+#if ARCH_32
+ public static readonly int Size = 4;
+
+ public static readonly nint MaxValue = Int32.MaxValue;
+ public static readonly nint MinValue = Int32.MinValue;
+
+ [DebuggerBrowsable (DebuggerBrowsableState.Never)]
+ internal Int32 v;
+
+ public nint (Int64 v) { this.v = (Int32)v; }
+#else
+ public static readonly int Size = 8;
+
+ public static readonly nint MaxValue = (nint) Int64.MaxValue; // 64-bit only codepath
+ public static readonly nint MinValue = (nint) Int64.MinValue; // 64-bit only codepath
+
+ [DebuggerBrowsable (DebuggerBrowsableState.Never)]
+ internal Int64 v;
+
+ public nint (Int64 v) { this.v = v; }
+#endif
+
+ public static explicit operator nint (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v.v);
+#else
+ return new nint ((long)v.v);
+#endif
+ }
+
+ public static explicit operator nuint (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v.v);
+#else
+ return new nuint ((ulong)v.v);
+#endif
+ }
+
+ public static explicit operator nint (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v.v);
+#else
+ return new nint ((long)v.v);
+#endif
+ }
+
+ public static implicit operator nfloat (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v.v);
+#else
+ return new nfloat ((double)v.v);
+#endif
+ }
+
+ public static explicit operator nint (IntPtr v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint (*((int *)&v));
+#else
+ return new nint (*((long *)&v));
+#endif
+ }
+
+ public static explicit operator IntPtr (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return *((IntPtr *)&v.v);
+#else
+ return *((IntPtr *)&v.v);
+#endif
+ }
+
+ public static implicit operator nint (sbyte v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static explicit operator sbyte (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (sbyte)v.v;
+#else
+ return (sbyte)v.v;
+#endif
+ }
+
+ public static implicit operator nint (byte v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static explicit operator byte (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (byte)v.v;
+#else
+ return (byte)v.v;
+#endif
+ }
+
+ public static implicit operator nint (char v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static explicit operator char (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (char)v.v;
+#else
+ return (char)v.v;
+#endif
+ }
+
+ public static implicit operator nint (short v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static explicit operator short (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (short)v.v;
+#else
+ return (short)v.v;
+#endif
+ }
+
+ public static explicit operator nint (ushort v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static explicit operator ushort (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (ushort)v.v;
+#else
+ return (ushort)v.v;
+#endif
+ }
+
+ public static implicit operator nint (int v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static explicit operator int (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (int)v.v;
+#else
+ return (int)v.v;
+#endif
+ }
+
+ public static explicit operator nint (uint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static explicit operator uint (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (uint)v.v;
+#else
+ return (uint)v.v;
+#endif
+ }
+
+ public static explicit operator nint (long v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static implicit operator long (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (long)v.v;
+#else
+ return (long)v.v;
+#endif
+ }
+
+ public static explicit operator nint (ulong v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static explicit operator ulong (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (ulong)v.v;
+#else
+ return (ulong)v.v;
+#endif
+ }
+
+ public static explicit operator nint (float v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static implicit operator float (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (float)v.v;
+#else
+ return (float)v.v;
+#endif
+ }
+
+ public static explicit operator nint (double v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static implicit operator double (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (double)v.v;
+#else
+ return (double)v.v;
+#endif
+ }
+
+ public static explicit operator nint (decimal v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nint ((int)v);
+#else
+ return new nint ((long)v);
+#endif
+ }
+
+ public static implicit operator decimal (nint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (decimal)v.v;
+#else
+ return (decimal)v.v;
+#endif
+ }
+
+#if NINT_JIT_OPTIMIZED
+ public static nint operator + (nint v) { throw new NotImplementedException (); }
+ public static nint operator - (nint v) { throw new NotImplementedException (); }
+ public static nint operator ~ (nint v) { throw new NotImplementedException (); }
+#else
+ public static nint operator + (nint v) { return new nint (+v.v); }
+ public static nint operator - (nint v) { return new nint (-v.v); }
+ public static nint operator ~ (nint v) { return new nint (~v.v); }
+#endif
+
+#if NINT_JIT_OPTIMIZED
+ public static nint operator ++ (nint v) { throw new NotImplementedException (); }
+ public static nint operator -- (nint v) { throw new NotImplementedException (); }
+#else
+ public static nint operator ++ (nint v) { return new nint (v.v + 1); }
+ public static nint operator -- (nint v) { return new nint (v.v - 1); }
+#endif
+
+#if NINT_JIT_OPTIMIZED
+ public static nint operator + (nint l, nint r) { throw new NotImplementedException (); }
+ public static nint operator - (nint l, nint r) { throw new NotImplementedException (); }
+ public static nint operator * (nint l, nint r) { throw new NotImplementedException (); }
+ public static nint operator / (nint l, nint r) { throw new NotImplementedException (); }
+ public static nint operator % (nint l, nint r) { throw new NotImplementedException (); }
+ public static nint operator & (nint l, nint r) { throw new NotImplementedException (); }
+ public static nint operator | (nint l, nint r) { throw new NotImplementedException (); }
+ public static nint operator ^ (nint l, nint r) { throw new NotImplementedException (); }
+
+ public static nint operator << (nint l, int r) { throw new NotImplementedException (); }
+ public static nint operator >> (nint l, int r) { throw new NotImplementedException (); }
+#else
+ public static nint operator + (nint l, nint r) { return new nint (l.v + r.v); }
+ public static nint operator - (nint l, nint r) { return new nint (l.v - r.v); }
+ public static nint operator * (nint l, nint r) { return new nint (l.v * r.v); }
+ public static nint operator / (nint l, nint r) { return new nint (l.v / r.v); }
+ public static nint operator % (nint l, nint r) { return new nint (l.v % r.v); }
+ public static nint operator & (nint l, nint r) { return new nint (l.v & r.v); }
+ public static nint operator | (nint l, nint r) { return new nint (l.v | r.v); }
+ public static nint operator ^ (nint l, nint r) { return new nint (l.v ^ r.v); }
+
+ public static nint operator << (nint l, int r) { return new nint (l.v << r); }
+ public static nint operator >> (nint l, int r) { return new nint (l.v >> r); }
+#endif
+
+#if NINT_JIT_OPTIMIZED
+ public static bool operator == (nint l, nint r) { throw new NotImplementedException (); }
+ public static bool operator != (nint l, nint r) { throw new NotImplementedException (); }
+ public static bool operator < (nint l, nint r) { throw new NotImplementedException (); }
+ public static bool operator > (nint l, nint r) { throw new NotImplementedException (); }
+ public static bool operator <= (nint l, nint r) { throw new NotImplementedException (); }
+ public static bool operator >= (nint l, nint r) { throw new NotImplementedException (); }
+#else
+ public static bool operator == (nint l, nint r) { return l.v == r.v; }
+ public static bool operator != (nint l, nint r) { return l.v != r.v; }
+ public static bool operator < (nint l, nint r) { return l.v < r.v; }
+ public static bool operator > (nint l, nint r) { return l.v > r.v; }
+ public static bool operator <= (nint l, nint r) { return l.v <= r.v; }
+ public static bool operator >= (nint l, nint r) { return l.v >= r.v; }
+#endif
+
+ public int CompareTo (nint value) { return v.CompareTo (value.v); }
+ public int CompareTo (object value)
+ {
+ if (value is nint)
+ return v.CompareTo (((nint) value).v);
+ return v.CompareTo (value);
+ }
+ public bool Equals (nint obj) { return v.Equals (obj.v); }
+ public override bool Equals (object obj)
+ {
+ if (obj is nint)
+ return v.Equals (((nint) obj).v);
+ return v.Equals (obj);
+ }
+ public override int GetHashCode () { return v.GetHashCode (); }
+
+#if ARCH_32
+ public static nint Parse (string s, IFormatProvider provider) { return (nint)Int32.Parse (s, provider); }
+ public static nint Parse (string s, NumberStyles style) { return (nint)Int32.Parse (s, style); }
+ public static nint Parse (string s) { return (nint)Int32.Parse (s); }
+ public static nint Parse (string s, NumberStyles style, IFormatProvider provider) {
+ return (nint)Int32.Parse (s, style, provider);
+ }
+
+ public static bool TryParse (string s, out nint result)
+ {
+ Int32 v;
+ var r = Int32.TryParse (s, out v);
+ result = (nint)v;
+ return r;
+ }
+
+ public static bool TryParse (string s, NumberStyles style, IFormatProvider provider, out nint result)
+ {
+ Int32 v;
+ var r = Int32.TryParse (s, style, provider, out v);
+ result = (nint)v;
+ return r;
+ }
+#else
+ public static nint Parse (string s, IFormatProvider provider) { return (nint)Int64.Parse (s, provider); }
+ public static nint Parse (string s, NumberStyles style) { return (nint)Int64.Parse (s, style); }
+ public static nint Parse (string s) { return (nint)Int64.Parse (s); }
+ public static nint Parse (string s, NumberStyles style, IFormatProvider provider) {
+ return (nint)Int64.Parse (s, style, provider);
+ }
+
+ public static bool TryParse (string s, out nint result)
+ {
+ Int64 v;
+ var r = Int64.TryParse (s, out v);
+ result = (nint)v;
+ return r;
+ }
+
+ public static bool TryParse (string s, NumberStyles style, IFormatProvider provider, out nint result)
+ {
+ Int64 v;
+ var r = Int64.TryParse (s, style, provider, out v);
+ result = (nint)v;
+ return r;
+ }
+#endif
+
+ public override string ToString () { return v.ToString (); }
+ public string ToString (IFormatProvider provider) { return v.ToString (provider); }
+ public string ToString (string format) { return v.ToString (format); }
+ public string ToString (string format, IFormatProvider provider) { return v.ToString (format, provider); }
+
+ public TypeCode GetTypeCode () { return v.GetTypeCode (); }
+
+ bool IConvertible.ToBoolean (IFormatProvider provider) { return ((IConvertible)v).ToBoolean (provider); }
+ byte IConvertible.ToByte (IFormatProvider provider) { return ((IConvertible)v).ToByte (provider); }
+ char IConvertible.ToChar (IFormatProvider provider) { return ((IConvertible)v).ToChar (provider); }
+ DateTime IConvertible.ToDateTime (IFormatProvider provider) { return ((IConvertible)v).ToDateTime (provider); }
+ decimal IConvertible.ToDecimal (IFormatProvider provider) { return ((IConvertible)v).ToDecimal (provider); }
+ double IConvertible.ToDouble (IFormatProvider provider) { return ((IConvertible)v).ToDouble (provider); }
+ short IConvertible.ToInt16 (IFormatProvider provider) { return ((IConvertible)v).ToInt16 (provider); }
+ int IConvertible.ToInt32 (IFormatProvider provider) { return ((IConvertible)v).ToInt32 (provider); }
+ long IConvertible.ToInt64 (IFormatProvider provider) { return ((IConvertible)v).ToInt64 (provider); }
+ sbyte IConvertible.ToSByte (IFormatProvider provider) { return ((IConvertible)v).ToSByte (provider); }
+ float IConvertible.ToSingle (IFormatProvider provider) { return ((IConvertible)v).ToSingle (provider); }
+ ushort IConvertible.ToUInt16 (IFormatProvider provider) { return ((IConvertible)v).ToUInt16 (provider); }
+ uint IConvertible.ToUInt32 (IFormatProvider provider) { return ((IConvertible)v).ToUInt32 (provider); }
+ ulong IConvertible.ToUInt64 (IFormatProvider provider) { return ((IConvertible)v).ToUInt64 (provider); }
+
+ object IConvertible.ToType (Type targetType, IFormatProvider provider) {
+ return ((IConvertible)v).ToType (targetType, provider);
+ }
+
+ public static void CopyArray (IntPtr source, nint [] destination, int startIndex, int length)
+ {
+ if (source == IntPtr.Zero)
+ throw new ArgumentNullException ("source");
+ if (destination == null)
+ throw new ArgumentNullException ("destination");
+ if (destination.Rank != 1)
+ throw new ArgumentException ("destination", "array is multi-dimensional");
+ if (startIndex < 0)
+ throw new ArgumentException ("startIndex", "must be >= 0");
+ if (length < 0)
+ throw new ArgumentException ("length", "must be >= 0");
+ if (startIndex + length > destination.Length)
+ throw new ArgumentException ("length", "startIndex + length > destination.Length");
+
+ for (int i = 0; i < length; i++)
+ destination [i + startIndex] = (nint)Marshal.ReadIntPtr (source, i * nint.Size);
+ }
+
+ public static void CopyArray (nint [] source, int startIndex, IntPtr destination, int length)
+ {
+ if (source == null)
+ throw new ArgumentNullException ("source");
+ if (destination == IntPtr.Zero)
+ throw new ArgumentNullException ("destination");
+ if (source.Rank != 1)
+ throw new ArgumentException ("source", "array is multi-dimensional");
+ if (startIndex < 0)
+ throw new ArgumentException ("startIndex", "must be >= 0");
+ if (length < 0)
+ throw new ArgumentException ("length", "must be >= 0");
+ if (startIndex + length > source.Length)
+ throw new ArgumentException ("length", "startIndex + length > source.Length");
+
+ for (int i = 0; i < length; i++)
+ Marshal.WriteIntPtr (destination, i * nint.Size, (IntPtr)source [i + startIndex]);
+ }
+ }
+ [Serializable]
+ [DebuggerDisplay ("{v,nq}")]
+ public unsafe struct nuint : IFormattable, IConvertible, IComparable, IComparable<nuint>, IEquatable <nuint>
+ {
+ internal nuint (nuint v) { this.v = v.v; }
+ public nuint (UInt32 v) { this.v = v; }
+
+#if ARCH_32
+ public static readonly int Size = 4;
+
+ public static readonly nuint MaxValue = UInt32.MaxValue;
+ public static readonly nuint MinValue = UInt32.MinValue;
+
+ [DebuggerBrowsable (DebuggerBrowsableState.Never)]
+ internal UInt32 v;
+
+ public nuint (UInt64 v) { this.v = (UInt32)v; }
+#else
+ public static readonly int Size = 8;
+
+ public static readonly nuint MaxValue = (nuint) UInt64.MaxValue; // 64-bit only codepath
+ public static readonly nuint MinValue = (nuint) UInt64.MinValue; // 64-bit only codepath
+
+ [DebuggerBrowsable (DebuggerBrowsableState.Never)]
+ internal UInt64 v;
+
+ public nuint (UInt64 v) { this.v = v; }
+#endif
+
+ public static explicit operator nuint (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v.v);
+#else
+ return new nuint ((ulong)v.v);
+#endif
+ }
+
+ public static implicit operator nfloat (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v.v);
+#else
+ return new nfloat ((double)v.v);
+#endif
+ }
+
+ public static explicit operator nuint (IntPtr v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint (*((uint *)&v));
+#else
+ return new nuint (*((ulong *)&v));
+#endif
+ }
+
+ public static explicit operator IntPtr (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return *((IntPtr *)&v.v);
+#else
+ return *((IntPtr *)&v.v);
+#endif
+ }
+
+ public static explicit operator nuint (sbyte v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static explicit operator sbyte (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (sbyte)v.v;
+#else
+ return (sbyte)v.v;
+#endif
+ }
+
+ public static implicit operator nuint (byte v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static explicit operator byte (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (byte)v.v;
+#else
+ return (byte)v.v;
+#endif
+ }
+
+ public static implicit operator nuint (char v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static explicit operator char (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (char)v.v;
+#else
+ return (char)v.v;
+#endif
+ }
+
+ public static explicit operator nuint (short v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static explicit operator short (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (short)v.v;
+#else
+ return (short)v.v;
+#endif
+ }
+
+ public static implicit operator nuint (ushort v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static explicit operator ushort (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (ushort)v.v;
+#else
+ return (ushort)v.v;
+#endif
+ }
+
+ public static explicit operator nuint (int v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static explicit operator int (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (int)v.v;
+#else
+ return (int)v.v;
+#endif
+ }
+
+ public static implicit operator nuint (uint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static explicit operator uint (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (uint)v.v;
+#else
+ return (uint)v.v;
+#endif
+ }
+
+ public static explicit operator nuint (long v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static explicit operator long (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (long)v.v;
+#else
+ return (long)v.v;
+#endif
+ }
+
+ public static explicit operator nuint (ulong v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static implicit operator ulong (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (ulong)v.v;
+#else
+ return (ulong)v.v;
+#endif
+ }
+
+ public static explicit operator nuint (float v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static implicit operator float (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (float)v.v;
+#else
+ return (float)v.v;
+#endif
+ }
+
+ public static explicit operator nuint (double v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static implicit operator double (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (double)v.v;
+#else
+ return (double)v.v;
+#endif
+ }
+
+ public static explicit operator nuint (decimal v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nuint ((uint)v);
+#else
+ return new nuint ((ulong)v);
+#endif
+ }
+
+ public static implicit operator decimal (nuint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (decimal)v.v;
+#else
+ return (decimal)v.v;
+#endif
+ }
+
+#if NINT_JIT_OPTIMIZED
+ public static nuint operator + (nuint v) { throw new NotImplementedException (); }
+ public static nuint operator ~ (nuint v) { throw new NotImplementedException (); }
+#else
+ public static nuint operator + (nuint v) { return new nuint (+v.v); }
+ public static nuint operator ~ (nuint v) { return new nuint (~v.v); }
+#endif
+
+#if NINT_JIT_OPTIMIZED
+ public static nuint operator ++ (nuint v) { throw new NotImplementedException (); }
+ public static nuint operator -- (nuint v) { throw new NotImplementedException (); }
+#else
+ public static nuint operator ++ (nuint v) { return new nuint (v.v + 1); }
+ public static nuint operator -- (nuint v) { return new nuint (v.v - 1); }
+#endif
+
+#if NINT_JIT_OPTIMIZED
+ public static nuint operator + (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static nuint operator - (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static nuint operator * (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static nuint operator / (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static nuint operator % (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static nuint operator & (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static nuint operator | (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static nuint operator ^ (nuint l, nuint r) { throw new NotImplementedException (); }
+
+ public static nuint operator << (nuint l, int r) { throw new NotImplementedException (); }
+ public static nuint operator >> (nuint l, int r) { throw new NotImplementedException (); }
+#else
+ public static nuint operator + (nuint l, nuint r) { return new nuint (l.v + r.v); }
+ public static nuint operator - (nuint l, nuint r) { return new nuint (l.v - r.v); }
+ public static nuint operator * (nuint l, nuint r) { return new nuint (l.v * r.v); }
+ public static nuint operator / (nuint l, nuint r) { return new nuint (l.v / r.v); }
+ public static nuint operator % (nuint l, nuint r) { return new nuint (l.v % r.v); }
+ public static nuint operator & (nuint l, nuint r) { return new nuint (l.v & r.v); }
+ public static nuint operator | (nuint l, nuint r) { return new nuint (l.v | r.v); }
+ public static nuint operator ^ (nuint l, nuint r) { return new nuint (l.v ^ r.v); }
+
+ public static nuint operator << (nuint l, int r) { return new nuint (l.v << r); }
+ public static nuint operator >> (nuint l, int r) { return new nuint (l.v >> r); }
+#endif
+
+#if NINT_JIT_OPTIMIZED
+ public static bool operator == (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static bool operator != (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static bool operator < (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static bool operator > (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static bool operator <= (nuint l, nuint r) { throw new NotImplementedException (); }
+ public static bool operator >= (nuint l, nuint r) { throw new NotImplementedException (); }
+#else
+ public static bool operator == (nuint l, nuint r) { return l.v == r.v; }
+ public static bool operator != (nuint l, nuint r) { return l.v != r.v; }
+ public static bool operator < (nuint l, nuint r) { return l.v < r.v; }
+ public static bool operator > (nuint l, nuint r) { return l.v > r.v; }
+ public static bool operator <= (nuint l, nuint r) { return l.v <= r.v; }
+ public static bool operator >= (nuint l, nuint r) { return l.v >= r.v; }
+#endif
+
+ public int CompareTo (nuint value) { return v.CompareTo (value.v); }
+ public int CompareTo (object value)
+ {
+ if (value is nuint)
+ return v.CompareTo (((nuint) value).v);
+ return v.CompareTo (value);
+ }
+ public bool Equals (nuint obj) { return v.Equals (obj.v); }
+ public override bool Equals (object obj)
+ {
+ if (obj is nuint)
+ return v.Equals (((nuint) obj).v);
+ return v.Equals (obj);
+ }
+ public override int GetHashCode () { return v.GetHashCode (); }
+
+#if ARCH_32
+ public static nuint Parse (string s, IFormatProvider provider) { return (nuint)UInt32.Parse (s, provider); }
+ public static nuint Parse (string s, NumberStyles style) { return (nuint)UInt32.Parse (s, style); }
+ public static nuint Parse (string s) { return (nuint)UInt32.Parse (s); }
+ public static nuint Parse (string s, NumberStyles style, IFormatProvider provider) {
+ return (nuint)UInt32.Parse (s, style, provider);
+ }
+
+ public static bool TryParse (string s, out nuint result)
+ {
+ UInt32 v;
+ var r = UInt32.TryParse (s, out v);
+ result = (nuint)v;
+ return r;
+ }
+
+ public static bool TryParse (string s, NumberStyles style, IFormatProvider provider, out nuint result)
+ {
+ UInt32 v;
+ var r = UInt32.TryParse (s, style, provider, out v);
+ result = (nuint)v;
+ return r;
+ }
+#else
+ public static nuint Parse (string s, IFormatProvider provider) { return (nuint)UInt64.Parse (s, provider); }
+ public static nuint Parse (string s, NumberStyles style) { return (nuint)UInt64.Parse (s, style); }
+ public static nuint Parse (string s) { return (nuint)UInt64.Parse (s); }
+ public static nuint Parse (string s, NumberStyles style, IFormatProvider provider) {
+ return (nuint)UInt64.Parse (s, style, provider);
+ }
+
+ public static bool TryParse (string s, out nuint result)
+ {
+ UInt64 v;
+ var r = UInt64.TryParse (s, out v);
+ result = (nuint)v;
+ return r;
+ }
+
+ public static bool TryParse (string s, NumberStyles style, IFormatProvider provider, out nuint result)
+ {
+ UInt64 v;
+ var r = UInt64.TryParse (s, style, provider, out v);
+ result = (nuint)v;
+ return r;
+ }
+#endif
+
+ public override string ToString () { return v.ToString (); }
+ public string ToString (IFormatProvider provider) { return v.ToString (provider); }
+ public string ToString (string format) { return v.ToString (format); }
+ public string ToString (string format, IFormatProvider provider) { return v.ToString (format, provider); }
+
+ public TypeCode GetTypeCode () { return v.GetTypeCode (); }
+
+ bool IConvertible.ToBoolean (IFormatProvider provider) { return ((IConvertible)v).ToBoolean (provider); }
+ byte IConvertible.ToByte (IFormatProvider provider) { return ((IConvertible)v).ToByte (provider); }
+ char IConvertible.ToChar (IFormatProvider provider) { return ((IConvertible)v).ToChar (provider); }
+ DateTime IConvertible.ToDateTime (IFormatProvider provider) { return ((IConvertible)v).ToDateTime (provider); }
+ decimal IConvertible.ToDecimal (IFormatProvider provider) { return ((IConvertible)v).ToDecimal (provider); }
+ double IConvertible.ToDouble (IFormatProvider provider) { return ((IConvertible)v).ToDouble (provider); }
+ short IConvertible.ToInt16 (IFormatProvider provider) { return ((IConvertible)v).ToInt16 (provider); }
+ int IConvertible.ToInt32 (IFormatProvider provider) { return ((IConvertible)v).ToInt32 (provider); }
+ long IConvertible.ToInt64 (IFormatProvider provider) { return ((IConvertible)v).ToInt64 (provider); }
+ sbyte IConvertible.ToSByte (IFormatProvider provider) { return ((IConvertible)v).ToSByte (provider); }
+ float IConvertible.ToSingle (IFormatProvider provider) { return ((IConvertible)v).ToSingle (provider); }
+ ushort IConvertible.ToUInt16 (IFormatProvider provider) { return ((IConvertible)v).ToUInt16 (provider); }
+ uint IConvertible.ToUInt32 (IFormatProvider provider) { return ((IConvertible)v).ToUInt32 (provider); }
+ ulong IConvertible.ToUInt64 (IFormatProvider provider) { return ((IConvertible)v).ToUInt64 (provider); }
+
+ object IConvertible.ToType (Type targetType, IFormatProvider provider) {
+ return ((IConvertible)v).ToType (targetType, provider);
+ }
+
+ public static void CopyArray (IntPtr source, nuint [] destination, int startIndex, int length)
+ {
+ if (source == IntPtr.Zero)
+ throw new ArgumentNullException ("source");
+ if (destination == null)
+ throw new ArgumentNullException ("destination");
+ if (destination.Rank != 1)
+ throw new ArgumentException ("destination", "array is multi-dimensional");
+ if (startIndex < 0)
+ throw new ArgumentException ("startIndex", "must be >= 0");
+ if (length < 0)
+ throw new ArgumentException ("length", "must be >= 0");
+ if (startIndex + length > destination.Length)
+ throw new ArgumentException ("length", "startIndex + length > destination.Length");
+
+ for (int i = 0; i < length; i++)
+ destination [i + startIndex] = (nuint)Marshal.ReadIntPtr (source, i * nuint.Size);
+ }
+
+ public static void CopyArray (nuint [] source, int startIndex, IntPtr destination, int length)
+ {
+ if (source == null)
+ throw new ArgumentNullException ("source");
+ if (destination == IntPtr.Zero)
+ throw new ArgumentNullException ("destination");
+ if (source.Rank != 1)
+ throw new ArgumentException ("source", "array is multi-dimensional");
+ if (startIndex < 0)
+ throw new ArgumentException ("startIndex", "must be >= 0");
+ if (length < 0)
+ throw new ArgumentException ("length", "must be >= 0");
+ if (startIndex + length > source.Length)
+ throw new ArgumentException ("length", "startIndex + length > source.Length");
+
+ for (int i = 0; i < length; i++)
+ Marshal.WriteIntPtr (destination, i * nuint.Size, (IntPtr)source [i + startIndex]);
+ }
+ }
+ [Serializable]
+ [DebuggerDisplay ("{v,nq}")]
+ public unsafe struct nfloat : IFormattable, IConvertible, IComparable, IComparable<nfloat>, IEquatable <nfloat>
+ {
+ internal nfloat (nfloat v) { this.v = v.v; }
+ public nfloat (Single v) { this.v = v; }
+
+#if ARCH_32
+ public static readonly int Size = 4;
+
+ public static readonly nfloat MaxValue = Single.MaxValue;
+ public static readonly nfloat MinValue = Single.MinValue;
+ public static readonly nfloat Epsilon = (nfloat)Single.Epsilon;
+ public static readonly nfloat NaN = (nfloat)Single.NaN;
+ public static readonly nfloat NegativeInfinity = (nfloat)Single.NegativeInfinity;
+ public static readonly nfloat PositiveInfinity = (nfloat)Single.PositiveInfinity;
+
+ [DebuggerBrowsable (DebuggerBrowsableState.Never)]
+ internal Single v;
+
+ public nfloat (Double v) { this.v = (Single)v; }
+#else
+ public static readonly int Size = 8;
+
+ public static readonly nfloat MaxValue = (nfloat) Double.MaxValue; // 64-bit only codepath
+ public static readonly nfloat MinValue = (nfloat) Double.MinValue; // 64-bit only codepath
+ public static readonly nfloat Epsilon = (nfloat)Double.Epsilon;
+ public static readonly nfloat NaN = (nfloat)Double.NaN;
+ public static readonly nfloat NegativeInfinity = (nfloat)Double.NegativeInfinity;
+ public static readonly nfloat PositiveInfinity = (nfloat)Double.PositiveInfinity;
+
+ [DebuggerBrowsable (DebuggerBrowsableState.Never)]
+ internal Double v;
+
+ public nfloat (Double v) { this.v = v; }
+#endif
+
+ public static explicit operator nfloat (IntPtr v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat (*((float *)&v));
+#else
+ return new nfloat (*((double *)&v));
+#endif
+ }
+
+ public static explicit operator IntPtr (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return *((IntPtr *)&v.v);
+#else
+ return *((IntPtr *)&v.v);
+#endif
+ }
+
+ public static implicit operator nfloat (sbyte v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator sbyte (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (sbyte)v.v;
+#else
+ return (sbyte)v.v;
+#endif
+ }
+
+ public static implicit operator nfloat (byte v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator byte (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (byte)v.v;
+#else
+ return (byte)v.v;
+#endif
+ }
+
+ public static implicit operator nfloat (char v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator char (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (char)v.v;
+#else
+ return (char)v.v;
+#endif
+ }
+
+ public static implicit operator nfloat (short v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator short (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (short)v.v;
+#else
+ return (short)v.v;
+#endif
+ }
+
+ public static implicit operator nfloat (ushort v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator ushort (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (ushort)v.v;
+#else
+ return (ushort)v.v;
+#endif
+ }
+
+ public static implicit operator nfloat (int v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator int (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (int)v.v;
+#else
+ return (int)v.v;
+#endif
+ }
+
+ public static implicit operator nfloat (uint v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator uint (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (uint)v.v;
+#else
+ return (uint)v.v;
+#endif
+ }
+
+ public static implicit operator nfloat (long v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator long (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (long)v.v;
+#else
+ return (long)v.v;
+#endif
+ }
+
+ public static implicit operator nfloat (ulong v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator ulong (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (ulong)v.v;
+#else
+ return (ulong)v.v;
+#endif
+ }
+
+ public static implicit operator nfloat (float v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator float (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (float)v.v;
+#else
+ return (float)v.v;
+#endif
+ }
+
+ public static explicit operator nfloat (double v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static implicit operator double (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (double)v.v;
+#else
+ return (double)v.v;
+#endif
+ }
+
+ public static explicit operator nfloat (decimal v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return new nfloat ((float)v);
+#else
+ return new nfloat ((double)v);
+#endif
+ }
+
+ public static explicit operator decimal (nfloat v)
+ {
+#if NINT_JIT_OPTIMIZED
+ throw new NotImplementedException ();
+#elif ARCH_32
+ return (decimal)v.v;
+#else
+ return (decimal)v.v;
+#endif
+ }
+
+#if NINT_JIT_OPTIMIZED
+ public static nfloat operator + (nfloat v) { throw new NotImplementedException (); }
+ public static nfloat operator - (nfloat v) { throw new NotImplementedException (); }
+#else
+ public static nfloat operator + (nfloat v) { return new nfloat (+v.v); }
+ public static nfloat operator - (nfloat v) { return new nfloat (-v.v); }
+#endif
+
+#if NINT_JIT_OPTIMIZED
+ public static nfloat operator ++ (nfloat v) { throw new NotImplementedException (); }
+ public static nfloat operator -- (nfloat v) { throw new NotImplementedException (); }
+#else
+ public static nfloat operator ++ (nfloat v) { return new nfloat (v.v + 1); }
+ public static nfloat operator -- (nfloat v) { return new nfloat (v.v - 1); }
+#endif
+
+#if NINT_JIT_OPTIMIZED
+ public static nfloat operator + (nfloat l, nfloat r) { throw new NotImplementedException (); }
+ public static nfloat operator - (nfloat l, nfloat r) { throw new NotImplementedException (); }
+ public static nfloat operator * (nfloat l, nfloat r) { throw new NotImplementedException (); }
+ public static nfloat operator / (nfloat l, nfloat r) { throw new NotImplementedException (); }
+ public static nfloat operator % (nfloat l, nfloat r) { throw new NotImplementedException (); }
+#else
+ public static nfloat operator + (nfloat l, nfloat r) { return new nfloat (l.v + r.v); }
+ public static nfloat operator - (nfloat l, nfloat r) { return new nfloat (l.v - r.v); }
+ public static nfloat operator * (nfloat l, nfloat r) { return new nfloat (l.v * r.v); }
+ public static nfloat operator / (nfloat l, nfloat r) { return new nfloat (l.v / r.v); }
+ public static nfloat operator % (nfloat l, nfloat r) { return new nfloat (l.v % r.v); }
+#endif
+
+#if NINT_JIT_OPTIMIZED
+ public static bool operator == (nfloat l, nfloat r) { throw new NotImplementedException (); }
+ public static bool operator != (nfloat l, nfloat r) { throw new NotImplementedException (); }
+ public static bool operator < (nfloat l, nfloat r) { throw new NotImplementedException (); }
+ public static bool operator > (nfloat l, nfloat r) { throw new NotImplementedException (); }
+ public static bool operator <= (nfloat l, nfloat r) { throw new NotImplementedException (); }
+ public static bool operator >= (nfloat l, nfloat r) { throw new NotImplementedException (); }
+#else
+ public static bool operator == (nfloat l, nfloat r) { return l.v == r.v; }
+ public static bool operator != (nfloat l, nfloat r) { return l.v != r.v; }
+ public static bool operator < (nfloat l, nfloat r) { return l.v < r.v; }
+ public static bool operator > (nfloat l, nfloat r) { return l.v > r.v; }
+ public static bool operator <= (nfloat l, nfloat r) { return l.v <= r.v; }
+ public static bool operator >= (nfloat l, nfloat r) { return l.v >= r.v; }
+#endif
+
+ public int CompareTo (nfloat value) { return v.CompareTo (value.v); }
+ public int CompareTo (object value)
+ {
+ if (value is nfloat)
+ return v.CompareTo (((nfloat) value).v);
+ return v.CompareTo (value);
+ }
+ public bool Equals (nfloat obj) { return v.Equals (obj.v); }
+ public override bool Equals (object obj)
+ {
+ if (obj is nfloat)
+ return v.Equals (((nfloat) obj).v);
+ return v.Equals (obj);
+ }
+ public override int GetHashCode () { return v.GetHashCode (); }
+
+#if ARCH_32
+ public static bool IsNaN (nfloat f) { return Single.IsNaN ((Single)f); }
+ public static bool IsInfinity (nfloat f) { return Single.IsInfinity ((Single)f); }
+ public static bool IsPositiveInfinity (nfloat f) { return Single.IsPositiveInfinity ((Single)f); }
+ public static bool IsNegativeInfinity (nfloat f) { return Single.IsNegativeInfinity ((Single)f); }
+
+ public static nfloat Parse (string s, IFormatProvider provider) { return (nfloat)Single.Parse (s, provider); }
+ public static nfloat Parse (string s, NumberStyles style) { return (nfloat)Single.Parse (s, style); }
+ public static nfloat Parse (string s) { return (nfloat)Single.Parse (s); }
+ public static nfloat Parse (string s, NumberStyles style, IFormatProvider provider) {
+ return (nfloat)Single.Parse (s, style, provider);
+ }
+
+ public static bool TryParse (string s, out nfloat result)
+ {
+ Single v;
+ var r = Single.TryParse (s, out v);
+ result = (nfloat)v;
+ return r;
+ }
+
+ public static bool TryParse (string s, NumberStyles style, IFormatProvider provider, out nfloat result)
+ {
+ Single v;
+ var r = Single.TryParse (s, style, provider, out v);
+ result = (nfloat)v;
+ return r;
+ }
+#else
+ public static bool IsNaN (nfloat f) { return Double.IsNaN ((Double)f); }
+ public static bool IsInfinity (nfloat f) { return Double.IsInfinity ((Double)f); }
+ public static bool IsPositiveInfinity (nfloat f) { return Double.IsPositiveInfinity ((Double)f); }
+ public static bool IsNegativeInfinity (nfloat f) { return Double.IsNegativeInfinity ((Double)f); }
+
+ public static nfloat Parse (string s, IFormatProvider provider) { return (nfloat)Double.Parse (s, provider); }
+ public static nfloat Parse (string s, NumberStyles style) { return (nfloat)Double.Parse (s, style); }
+ public static nfloat Parse (string s) { return (nfloat)Double.Parse (s); }
+ public static nfloat Parse (string s, NumberStyles style, IFormatProvider provider) {
+ return (nfloat)Double.Parse (s, style, provider);
+ }
+
+ public static bool TryParse (string s, out nfloat result)
+ {
+ Double v;
+ var r = Double.TryParse (s, out v);
+ result = (nfloat)v;
+ return r;
+ }
+
+ public static bool TryParse (string s, NumberStyles style, IFormatProvider provider, out nfloat result)
+ {
+ Double v;
+ var r = Double.TryParse (s, style, provider, out v);
+ result = (nfloat)v;
+ return r;
+ }
+#endif
+
+ public override string ToString () { return v.ToString (); }
+ public string ToString (IFormatProvider provider) { return v.ToString (provider); }
+ public string ToString (string format) { return v.ToString (format); }
+ public string ToString (string format, IFormatProvider provider) { return v.ToString (format, provider); }
+
+ public TypeCode GetTypeCode () { return v.GetTypeCode (); }
+
+ bool IConvertible.ToBoolean (IFormatProvider provider) { return ((IConvertible)v).ToBoolean (provider); }
+ byte IConvertible.ToByte (IFormatProvider provider) { return ((IConvertible)v).ToByte (provider); }
+ char IConvertible.ToChar (IFormatProvider provider) { return ((IConvertible)v).ToChar (provider); }
+ DateTime IConvertible.ToDateTime (IFormatProvider provider) { return ((IConvertible)v).ToDateTime (provider); }
+ decimal IConvertible.ToDecimal (IFormatProvider provider) { return ((IConvertible)v).ToDecimal (provider); }
+ double IConvertible.ToDouble (IFormatProvider provider) { return ((IConvertible)v).ToDouble (provider); }
+ short IConvertible.ToInt16 (IFormatProvider provider) { return ((IConvertible)v).ToInt16 (provider); }
+ int IConvertible.ToInt32 (IFormatProvider provider) { return ((IConvertible)v).ToInt32 (provider); }
+ long IConvertible.ToInt64 (IFormatProvider provider) { return ((IConvertible)v).ToInt64 (provider); }
+ sbyte IConvertible.ToSByte (IFormatProvider provider) { return ((IConvertible)v).ToSByte (provider); }
+ float IConvertible.ToSingle (IFormatProvider provider) { return ((IConvertible)v).ToSingle (provider); }
+ ushort IConvertible.ToUInt16 (IFormatProvider provider) { return ((IConvertible)v).ToUInt16 (provider); }
+ uint IConvertible.ToUInt32 (IFormatProvider provider) { return ((IConvertible)v).ToUInt32 (provider); }
+ ulong IConvertible.ToUInt64 (IFormatProvider provider) { return ((IConvertible)v).ToUInt64 (provider); }
+
+ object IConvertible.ToType (Type targetType, IFormatProvider provider) {
+ return ((IConvertible)v).ToType (targetType, provider);
+ }
+
+ public static void CopyArray (IntPtr source, nfloat [] destination, int startIndex, int length)
+ {
+ if (source == IntPtr.Zero)
+ throw new ArgumentNullException ("source");
+ if (destination == null)
+ throw new ArgumentNullException ("destination");
+ if (destination.Rank != 1)
+ throw new ArgumentException ("destination", "array is multi-dimensional");
+ if (startIndex < 0)
+ throw new ArgumentException ("startIndex", "must be >= 0");
+ if (length < 0)
+ throw new ArgumentException ("length", "must be >= 0");
+ if (startIndex + length > destination.Length)
+ throw new ArgumentException ("length", "startIndex + length > destination.Length");
+
+ for (int i = 0; i < length; i++)
+ destination [i + startIndex] = (nfloat)Marshal.ReadIntPtr (source, i * nfloat.Size);
+ }
+
+ public static void CopyArray (nfloat [] source, int startIndex, IntPtr destination, int length)
+ {
+ if (source == null)
+ throw new ArgumentNullException ("source");
+ if (destination == IntPtr.Zero)
+ throw new ArgumentNullException ("destination");
+ if (source.Rank != 1)
+ throw new ArgumentException ("source", "array is multi-dimensional");
+ if (startIndex < 0)
+ throw new ArgumentException ("startIndex", "must be >= 0");
+ if (length < 0)
+ throw new ArgumentException ("length", "must be >= 0");
+ if (startIndex + length > source.Length)
+ throw new ArgumentException ("length", "startIndex + length > source.Length");
+
+ for (int i = 0; i < length; i++)
+ Marshal.WriteIntPtr (destination, i * nfloat.Size, (IntPtr)source [i + startIndex]);
+ }
+ }
+}
projects / mono.git / commitdiff