2399 lines
60 KiB
C#
2399 lines
60 KiB
C#
// #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;
|
|
}
|
|
|
|
#if !__MOBILE__
|
|
public static int Main (String[] args) {
|
|
return TestDriver.RunTests (typeof (BuiltinTests), args);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
// !!! 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]);
|
|
}
|
|
}
|
|
}
|