// The MIT License(MIT)
|
//
|
// Copyright(c) Unity Technologies, Microsoft Corporation
|
//
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
// of this software and associated documentation files(the "Software"), to deal
|
// in the Software without restriction, including without limitation the rights
|
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
|
// copies of the Software, and to permit persons to whom the Software is
|
// furnished to do so, subject to the following conditions :
|
//
|
// The above copyright notice and this permission notice shall be included in all
|
// copies or substantial portions of the Software.
|
//
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
// SOFTWARE.
|
|
#include "il2cpp-config.h"
|
#include "Number.h"
|
#include "utils/StringUtils.h"
|
|
#include <algorithm>
|
|
#define NUMBER_MAXDIGITS 50
|
|
struct NUMBER
|
{
|
int precision;
|
int scale;
|
int sign;
|
Il2CppChar digits[NUMBER_MAXDIGITS + 1];
|
Il2CppChar* allDigits;
|
|
NUMBER() :
|
precision(0),
|
scale(0),
|
sign(0),
|
allDigits(NULL)
|
{
|
}
|
};
|
|
struct FPDOUBLE
|
{
|
#if IL2CPP_BYTE_ORDER == IL2CPP_BIG_ENDIAN
|
unsigned int sign : 1;
|
unsigned int exp : 11;
|
unsigned int mantHi : 20;
|
unsigned int mantLo;
|
#else
|
unsigned int mantLo;
|
unsigned int mantHi : 20;
|
unsigned int exp : 11;
|
unsigned int sign : 1;
|
#endif
|
};
|
|
|
//
|
// precomputed tables with powers of 10. These allows us to do at most
|
// two Mul64 during the conversion. This is important not only
|
// for speed, but also for precision because of Mul64 computes with 1 bit error.
|
//
|
static const uint64_t rgval64Power10[] =
|
{
|
// powers of 10
|
/*1*/ 0xa000000000000000ULL,
|
/*2*/ 0xc800000000000000ULL,
|
/*3*/ 0xfa00000000000000ULL,
|
/*4*/ 0x9c40000000000000ULL,
|
/*5*/ 0xc350000000000000ULL,
|
/*6*/ 0xf424000000000000ULL,
|
/*7*/ 0x9896800000000000ULL,
|
/*8*/ 0xbebc200000000000ULL,
|
/*9*/ 0xee6b280000000000ULL,
|
/*10*/ 0x9502f90000000000ULL,
|
/*11*/ 0xba43b74000000000ULL,
|
/*12*/ 0xe8d4a51000000000ULL,
|
/*13*/ 0x9184e72a00000000ULL,
|
/*14*/ 0xb5e620f480000000ULL,
|
/*15*/ 0xe35fa931a0000000ULL,
|
|
// powers of 0.1
|
/*1*/ 0xcccccccccccccccdULL,
|
/*2*/ 0xa3d70a3d70a3d70bULL,
|
/*3*/ 0x83126e978d4fdf3cULL,
|
/*4*/ 0xd1b71758e219652eULL,
|
/*5*/ 0xa7c5ac471b478425ULL,
|
/*6*/ 0x8637bd05af6c69b7ULL,
|
/*7*/ 0xd6bf94d5e57a42beULL,
|
/*8*/ 0xabcc77118461ceffULL,
|
/*9*/ 0x89705f4136b4a599ULL,
|
/*10*/ 0xdbe6fecebdedd5c2ULL,
|
/*11*/ 0xafebff0bcb24ab02ULL,
|
/*12*/ 0x8cbccc096f5088cfULL,
|
/*13*/ 0xe12e13424bb40e18ULL,
|
/*14*/ 0xb424dc35095cd813ULL,
|
/*15*/ 0x901d7cf73ab0acdcULL,
|
};
|
|
static const int8_t rgexp64Power10[] =
|
{
|
// exponents for both powers of 10 and 0.1
|
/*1*/ 4,
|
/*2*/ 7,
|
/*3*/ 10,
|
/*4*/ 14,
|
/*5*/ 17,
|
/*6*/ 20,
|
/*7*/ 24,
|
/*8*/ 27,
|
/*9*/ 30,
|
/*10*/ 34,
|
/*11*/ 37,
|
/*12*/ 40,
|
/*13*/ 44,
|
/*14*/ 47,
|
/*15*/ 50,
|
};
|
|
static const uint64_t rgval64Power10By16[] =
|
{
|
// powers of 10^16
|
/*1*/ 0x8e1bc9bf04000000ULL,
|
/*2*/ 0x9dc5ada82b70b59eULL,
|
/*3*/ 0xaf298d050e4395d6ULL,
|
/*4*/ 0xc2781f49ffcfa6d4ULL,
|
/*5*/ 0xd7e77a8f87daf7faULL,
|
/*6*/ 0xefb3ab16c59b14a0ULL,
|
/*7*/ 0x850fadc09923329cULL,
|
/*8*/ 0x93ba47c980e98cdeULL,
|
/*9*/ 0xa402b9c5a8d3a6e6ULL,
|
/*10*/ 0xb616a12b7fe617a8ULL,
|
/*11*/ 0xca28a291859bbf90ULL,
|
/*12*/ 0xe070f78d39275566ULL,
|
/*13*/ 0xf92e0c3537826140ULL,
|
/*14*/ 0x8a5296ffe33cc92cULL,
|
/*15*/ 0x9991a6f3d6bf1762ULL,
|
/*16*/ 0xaa7eebfb9df9de8aULL,
|
/*17*/ 0xbd49d14aa79dbc7eULL,
|
/*18*/ 0xd226fc195c6a2f88ULL,
|
/*19*/ 0xe950df20247c83f8ULL,
|
/*20*/ 0x81842f29f2cce373ULL,
|
/*21*/ 0x8fcac257558ee4e2ULL,
|
|
// powers of 0.1^16
|
/*1*/ 0xe69594bec44de160ULL,
|
/*2*/ 0xcfb11ead453994c3ULL,
|
/*3*/ 0xbb127c53b17ec165ULL,
|
/*4*/ 0xa87fea27a539e9b3ULL,
|
/*5*/ 0x97c560ba6b0919b5ULL,
|
/*6*/ 0x88b402f7fd7553abULL,
|
/*7*/ 0xf64335bcf065d3a0ULL,
|
/*8*/ 0xddd0467c64bce4c4ULL,
|
/*9*/ 0xc7caba6e7c5382edULL,
|
/*10*/ 0xb3f4e093db73a0b7ULL,
|
/*11*/ 0xa21727db38cb0053ULL,
|
/*12*/ 0x91ff83775423cc29ULL,
|
/*13*/ 0x8380dea93da4bc82ULL,
|
/*14*/ 0xece53cec4a314f00ULL,
|
/*15*/ 0xd5605fcdcf32e217ULL,
|
/*16*/ 0xc0314325637a1978ULL,
|
/*17*/ 0xad1c8eab5ee43ba2ULL,
|
/*18*/ 0x9becce62836ac5b0ULL,
|
/*19*/ 0x8c71dcd9ba0b495cULL,
|
/*20*/ 0xfd00b89747823938ULL,
|
/*21*/ 0xe3e27a444d8d991aULL,
|
};
|
|
static const int16_t rgexp64Power10By16[] =
|
{
|
// exponents for both powers of 10^16 and 0.1^16
|
/*1*/ 54,
|
/*2*/ 107,
|
/*3*/ 160,
|
/*4*/ 213,
|
/*5*/ 266,
|
/*6*/ 319,
|
/*7*/ 373,
|
/*8*/ 426,
|
/*9*/ 479,
|
/*10*/ 532,
|
/*11*/ 585,
|
/*12*/ 638,
|
/*13*/ 691,
|
/*14*/ 745,
|
/*15*/ 798,
|
/*16*/ 851,
|
/*17*/ 904,
|
/*18*/ 957,
|
/*19*/ 1010,
|
/*20*/ 1064,
|
/*21*/ 1117,
|
};
|
|
#define Mul32x32To64(a, b) ((uint64_t)((uint32_t)(a)) * (uint64_t)((uint32_t)(b)))
|
|
|
#ifdef _DEBUG
|
//
|
// slower high precision version of Mul64 for computation of the tables
|
//
|
static uint64_t Mul64Precise(uint64_t a, uint64_t b, int* pexp)
|
{
|
uint64_t hilo =
|
((Mul32x32To64(a >> 32, b) >> 1) +
|
(Mul32x32To64(a, b >> 32) >> 1) +
|
(Mul32x32To64(a, b) >> 33)) >> 30;
|
|
uint64_t val = Mul32x32To64(a >> 32, b >> 32) + (hilo >> 1) + (hilo & 1);
|
|
// normalize
|
if ((val & 0x8000000000000000L) == 0)
|
{
|
val <<= 1; *pexp -= 1;
|
}
|
|
return val;
|
}
|
|
//
|
// debug-only verification of the precomputed tables
|
//
|
static void CheckTable(uint64_t val, int exp, const void* table, int size, const char* name, int tabletype)
|
{
|
uint64_t multval = val;
|
int mulexp = exp;
|
bool fBad = false;
|
|
for (int i = 0; i < size; i++)
|
{
|
switch (tabletype)
|
{
|
case 1:
|
if (((uint64_t*)table)[i] != val)
|
{
|
if (!fBad)
|
{
|
fprintf(stderr, "%s:\n", name);
|
fBad = true;
|
}
|
fprintf(stderr, "/*%d*/ I64(0x%llx),\n", i + 1, val);
|
}
|
break;
|
case 2:
|
if (((int8_t*)table)[i] != exp)
|
{
|
if (!fBad)
|
{
|
fprintf(stderr, "%s:\n", name);
|
fBad = true;
|
}
|
fprintf(stderr, "/*%d*/ %d,\n", i + 1, exp);
|
}
|
break;
|
case 3:
|
if (((int16_t*)table)[i] != exp)
|
{
|
if (!fBad)
|
{
|
fprintf(stderr, "%s:\n", name);
|
fBad = true;
|
}
|
fprintf(stderr, "/*%d*/ %d,\n", i + 1, exp);
|
}
|
break;
|
default:
|
IL2CPP_ASSERT(false);
|
break;
|
}
|
|
exp += mulexp;
|
val = Mul64Precise(val, multval, &exp);
|
}
|
IL2CPP_ASSERT(!fBad || !"NumberToDouble table not correct. Correct version dumped to stderr.");
|
}
|
|
void CheckTables()
|
{
|
uint64_t val;
|
int exp;
|
|
val = 0xa000000000000000L; exp = 4; // 10
|
CheckTable(val, exp, rgval64Power10, 15, "rgval64Power10", 1);
|
CheckTable(val, exp, rgexp64Power10, 15, "rgexp64Power10", 2);
|
|
val = 0x8e1bc9bf04000000L; exp = 54; //10^16
|
CheckTable(val, exp, rgval64Power10By16, 21, "rgval64Power10By16", 1);
|
CheckTable(val, exp, rgexp64Power10By16, 21, "rgexp64Power10By16", 3);
|
|
val = 0xCCCCCCCCCCCCCCCDL; exp = -3; // 0.1
|
CheckTable(val, exp, rgval64Power10 + 15, 15, "rgval64Power10 - inv", 1);
|
|
val = 0xe69594bec44de160L; exp = -53; // 0.1^16
|
CheckTable(val, exp, rgval64Power10By16 + 21, 21, "rgval64Power10By16 - inv", 1);
|
}
|
|
#endif // _DEBUG
|
|
namespace il2cpp
|
{
|
namespace icalls
|
{
|
namespace mscorlib
|
{
|
namespace System
|
{
|
#define DECIMAL_NEG ((uint8_t)0x80)
|
#define DECIMAL_PRECISION 29
|
#define DECIMAL_SCALE(dec) ((dec).u.u.scale)
|
#define DECIMAL_SIGN(dec) ((dec).u.u.sign)
|
#define DECIMAL_SIGNSCALE(dec) ((dec).u.signscale)
|
#define DECIMAL_LO32(dec) ((dec).v.v.Lo32)
|
#define DECIMAL_MID32(dec) ((dec).v.v.Mid32)
|
#define DECIMAL_HI32(dec) ((dec).Hi32)
|
|
static void DecShiftLeft(Il2CppDecimal* value)
|
{
|
unsigned int c0 = DECIMAL_LO32(*value) & 0x80000000 ? 1 : 0;
|
unsigned int c1 = DECIMAL_MID32(*value) & 0x80000000 ? 1 : 0;
|
IL2CPP_ASSERT(value != NULL);
|
|
DECIMAL_LO32(*value) <<= 1;
|
DECIMAL_MID32(*value) = DECIMAL_MID32(*value) << 1 | c0;
|
DECIMAL_HI32(*value) = DECIMAL_HI32(*value) << 1 | c1;
|
}
|
|
static int D32AddCarry(uint32_t* value, uint32_t i)
|
{
|
uint32_t v = *value;
|
uint32_t sum = v + i;
|
*value = sum;
|
return sum < v || sum < i ? 1 : 0;
|
}
|
|
static void DecAdd(Il2CppDecimal *value, Il2CppDecimal* d)
|
{
|
IL2CPP_ASSERT(value != NULL && d != NULL);
|
|
if (D32AddCarry(&DECIMAL_LO32(*value), DECIMAL_LO32(*d)))
|
{
|
if (D32AddCarry(&DECIMAL_MID32(*value), 1))
|
{
|
D32AddCarry(&DECIMAL_HI32(*value), 1);
|
}
|
}
|
if (D32AddCarry(&DECIMAL_MID32(*value), DECIMAL_MID32(*d)))
|
{
|
D32AddCarry(&DECIMAL_HI32(*value), 1);
|
}
|
D32AddCarry(&DECIMAL_HI32(*value), DECIMAL_HI32(*d));
|
}
|
|
static void DecMul10(Il2CppDecimal* value)
|
{
|
Il2CppDecimal d = *value;
|
IL2CPP_ASSERT(value != NULL);
|
|
DecShiftLeft(value);
|
DecShiftLeft(value);
|
DecAdd(value, &d);
|
DecShiftLeft(value);
|
}
|
|
static void DecAddInt32(Il2CppDecimal* value, unsigned int i)
|
{
|
IL2CPP_ASSERT(value != NULL);
|
|
if (D32AddCarry(&DECIMAL_LO32(*value), i))
|
{
|
if (D32AddCarry(&DECIMAL_MID32(*value), 1))
|
{
|
D32AddCarry(&DECIMAL_HI32(*value), 1);
|
}
|
}
|
}
|
|
bool Number::NumberBufferToDecimal(uint8_t* number, Il2CppDecimal* value)
|
{
|
IL2CPP_ASSERT(number != NULL);
|
IL2CPP_ASSERT(value != NULL);
|
|
NUMBER* numberStruct = (NUMBER*)number;
|
Il2CppChar* p = numberStruct->digits;
|
Il2CppDecimal d;
|
int e = numberStruct->scale;
|
|
d.reserved = 0;
|
DECIMAL_SIGNSCALE(d) = 0;
|
DECIMAL_HI32(d) = 0;
|
DECIMAL_LO32(d) = 0;
|
DECIMAL_MID32(d) = 0;
|
IL2CPP_ASSERT(p != NULL);
|
if (!*p)
|
{
|
// To avoid risking an app-compat issue with pre 4.5 (where some app was illegally using Reflection to examine the internal scale bits), we'll only force
|
// the scale to 0 if the scale was previously positive
|
if (e > 0)
|
{
|
e = 0;
|
}
|
}
|
else
|
{
|
if (e > DECIMAL_PRECISION)
|
return 0;
|
while ((e > 0 || (*p && e > -28)) && (DECIMAL_HI32(d) < 0x19999999 || (DECIMAL_HI32(d) == 0x19999999 && (DECIMAL_MID32(d) < 0x99999999 || (DECIMAL_MID32(d) == 0x99999999 && (DECIMAL_LO32(d) < 0x99999999 || (DECIMAL_LO32(d) == 0x99999999 && *p <= '5')))))))
|
{
|
DecMul10(&d);
|
if (*p)
|
DecAddInt32(&d, *p++ - '0');
|
e--;
|
}
|
if (*p++ >= '5')
|
{
|
bool round = true;
|
if (*(p - 1) == '5' && *(p - 2) % 2 == 0)
|
{
|
// Check if previous digit is even, only if the when we are unsure whether hows to do Banker's rounding
|
// For digits > 5 we will be roundinp up anyway.
|
int count = 20; // Look at the next 20 digits to check to round
|
while (*p == '0' && count != 0)
|
{
|
p++;
|
count--;
|
}
|
if (*p == '\0' || count == 0)
|
round = false; // Do nothing
|
}
|
|
if (round)
|
{
|
DecAddInt32(&d, 1);
|
if ((DECIMAL_HI32(d) | DECIMAL_MID32(d) | DECIMAL_LO32(d)) == 0)
|
{
|
DECIMAL_HI32(d) = 0x19999999;
|
DECIMAL_MID32(d) = 0x99999999;
|
DECIMAL_LO32(d) = 0x9999999A;
|
e++;
|
}
|
}
|
}
|
}
|
if (e > 0)
|
return 0;
|
if (e <= -DECIMAL_PRECISION)
|
{
|
// Parsing a large scale zero can give you more precision than fits in the decimal.
|
// This should only happen for actual zeros or very small numbers that round to zero.
|
DECIMAL_SIGNSCALE(d) = 0;
|
DECIMAL_HI32(d) = 0;
|
DECIMAL_LO32(d) = 0;
|
DECIMAL_MID32(d) = 0;
|
DECIMAL_SCALE(d) = (DECIMAL_PRECISION - 1);
|
}
|
else
|
{
|
DECIMAL_SCALE(d) = (uint8_t)(-e);
|
}
|
|
DECIMAL_SIGN(d) = numberStruct->sign ? DECIMAL_NEG : 0;
|
*value = d;
|
return 1;
|
}
|
|
//
|
// get 32-bit integer from at most 9 digits
|
//
|
static inline unsigned DigitsToInt(Il2CppChar* p, int count)
|
{
|
IL2CPP_ASSERT(1 <= count && count <= 9);
|
Il2CppChar* end = p + count;
|
unsigned res = *p - '0';
|
|
for (p = p + 1; p < end; p++)
|
res = 10 * res + *p - '0';
|
|
return res;
|
}
|
|
static uint64_t Mul64Lossy(uint64_t a, uint64_t b, int* pexp)
|
{
|
// it's ok to losse some precision here - Mul64 will be called
|
// at most twice during the conversion, so the error won't propagate
|
// to any of the 53 significant bits of the result
|
uint64_t val = Mul32x32To64(a >> 32, b >> 32) +
|
(Mul32x32To64(a >> 32, b) >> 32) +
|
(Mul32x32To64(a, b >> 32) >> 32);
|
|
// normalize
|
if ((val & 0x8000000000000000ULL) == 0)
|
{
|
val <<= 1; *pexp -= 1;
|
}
|
|
return val;
|
}
|
|
static inline void NumberToDouble(NUMBER* number, double* value)
|
{
|
uint64_t val;
|
int exp;
|
Il2CppChar* src = number->digits;
|
int remaining;
|
int total;
|
int count;
|
int scale;
|
int absscale;
|
int index;
|
|
#ifdef _DEBUG
|
static bool fCheckedTables = false;
|
if (!fCheckedTables)
|
{
|
CheckTables();
|
fCheckedTables = true;
|
}
|
#endif // _DEBUG
|
|
total = (int)utils::StringUtils::StrLen(src);
|
remaining = total;
|
|
// skip the leading zeros
|
while (*src == '0')
|
{
|
remaining--;
|
src++;
|
}
|
|
if (remaining == 0)
|
{
|
*value = 0;
|
goto done;
|
}
|
|
count = std::min(remaining, 9);
|
remaining -= count;
|
val = DigitsToInt(src, count);
|
|
if (remaining > 0)
|
{
|
count = std::min(remaining, 9);
|
remaining -= count;
|
|
// get the denormalized power of 10
|
uint32_t mult = (uint32_t)(rgval64Power10[count - 1] >> (64 - rgexp64Power10[count - 1]));
|
val = Mul32x32To64(val, mult) + DigitsToInt(src + 9, count);
|
}
|
|
scale = number->scale - (total - remaining);
|
absscale = abs(scale);
|
if (absscale >= 22 * 16)
|
{
|
// overflow / underflow
|
*(uint64_t*)value = (scale > 0) ? 0x7FF0000000000000ULL : 0;
|
goto done;
|
}
|
|
exp = 64;
|
|
// normalize the mantissa
|
if ((val & 0xFFFFFFFF00000000ULL) == 0)
|
{
|
val <<= 32; exp -= 32;
|
}
|
if ((val & 0xFFFF000000000000ULL) == 0)
|
{
|
val <<= 16; exp -= 16;
|
}
|
if ((val & 0xFF00000000000000ULL) == 0)
|
{
|
val <<= 8; exp -= 8;
|
}
|
if ((val & 0xF000000000000000ULL) == 0)
|
{
|
val <<= 4; exp -= 4;
|
}
|
if ((val & 0xC000000000000000ULL) == 0)
|
{
|
val <<= 2; exp -= 2;
|
}
|
if ((val & 0x8000000000000000ULL) == 0)
|
{
|
val <<= 1; exp -= 1;
|
}
|
|
index = absscale & 15;
|
if (index)
|
{
|
int multexp = rgexp64Power10[index - 1];
|
// the exponents are shared between the inverted and regular table
|
exp += (scale < 0) ? (-multexp + 1) : multexp;
|
|
uint64_t multval = rgval64Power10[index + ((scale < 0) ? 15 : 0) - 1];
|
val = Mul64Lossy(val, multval, &exp);
|
}
|
|
index = absscale >> 4;
|
if (index)
|
{
|
int multexp = rgexp64Power10By16[index - 1];
|
// the exponents are shared between the inverted and regular table
|
exp += (scale < 0) ? (-multexp + 1) : multexp;
|
|
uint64_t multval = rgval64Power10By16[index + ((scale < 0) ? 21 : 0) - 1];
|
val = Mul64Lossy(val, multval, &exp);
|
}
|
|
|
// round & scale down
|
if ((uint32_t)val & (1 << 10))
|
{
|
// IEEE round to even
|
uint64_t tmp = val + ((1 << 10) - 1) + (((uint32_t)val >> 11) & 1);
|
if (tmp < val)
|
{
|
// overflow
|
tmp = (tmp >> 1) | 0x8000000000000000ULL;
|
exp += 1;
|
}
|
val = tmp;
|
}
|
|
// return the exponent to a biased state
|
exp += 0x3FE;
|
|
// handle overflow, underflow, "Epsilon - 1/2 Epsilon", denormalized, and the normal case
|
if (exp <= 0)
|
{
|
if (exp == -52 && (val >= 0x8000000000000058ULL))
|
{
|
// round X where {Epsilon > X >= 2.470328229206232730000000E-324} up to Epsilon (instead of down to zero)
|
val = 0x0000000000000001ULL;
|
}
|
else if (exp <= -52)
|
{
|
// underflow
|
val = 0;
|
}
|
else
|
{
|
// denormalized
|
val >>= (-exp + 11 + 1);
|
}
|
}
|
else if (exp >= 0x7FF)
|
{
|
// overflow
|
val = 0x7FF0000000000000ULL;
|
}
|
else
|
{
|
// normal postive exponent case
|
val = ((uint64_t)exp << 52) + ((val >> 11) & 0x000FFFFFFFFFFFFFULL);
|
}
|
|
*(uint64_t*)value = val;
|
|
done:
|
if (number->sign)
|
*(uint64_t*)value |= 0x8000000000000000ULL;
|
}
|
|
bool Number::NumberBufferToDouble(uint8_t* number, double* value)
|
{
|
double d = 0;
|
NumberToDouble((NUMBER*)number, &d);
|
unsigned int e = ((FPDOUBLE*)&d)->exp;
|
unsigned int fmntLow = ((FPDOUBLE*)&d)->mantLo;
|
unsigned int fmntHigh = ((FPDOUBLE*)&d)->mantHi;
|
|
if (e == 0x7FF)
|
return false;
|
|
if (e == 0 && fmntLow == 0 && fmntHigh == 0)
|
d = 0;
|
|
*value = d;
|
return true;
|
}
|
} // namespace System
|
} // namespace mscorlib
|
} // namespace icalls
|
} // namespace il2cpp
|
