niko
2929 lines
69 KiB
C#
2929 lines
69 KiB
C#
using System;
|
|
using System.Globalization;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
|
|
namespace System
|
|
{
|
|
// Token: 0x02000698 RID: 1688
|
|
internal sealed class NumberFormatter
|
|
{
|
|
// Token: 0x06003FEB RID: 16363 RVA: 0x000D7B54 File Offset: 0x000D5D54
|
|
public NumberFormatter(Thread current)
|
|
{
|
|
this._cbuf = new char[0];
|
|
if (current == null)
|
|
{
|
|
return;
|
|
}
|
|
this._thread = current;
|
|
this.CurrentCulture = this._thread.CurrentCulture;
|
|
}
|
|
|
|
// Token: 0x06003FEC RID: 16364 RVA: 0x000D7B88 File Offset: 0x000D5D88
|
|
static NumberFormatter()
|
|
{
|
|
NumberFormatter.GetFormatterTables(out NumberFormatter.MantissaBitsTable, out NumberFormatter.TensExponentTable, out NumberFormatter.DigitLowerTable, out NumberFormatter.DigitUpperTable, out NumberFormatter.TenPowersList, out NumberFormatter.DecHexDigits);
|
|
}
|
|
|
|
// Token: 0x06003FED RID: 16365
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private unsafe static extern void GetFormatterTables(out ulong* MantissaBitsTable, out int* TensExponentTable, out char* DigitLowerTable, out char* DigitUpperTable, out long* TenPowersList, out int* DecHexDigits);
|
|
|
|
// Token: 0x06003FEE RID: 16366 RVA: 0x000D7BB0 File Offset: 0x000D5DB0
|
|
private unsafe static long GetTenPowerOf(int i)
|
|
{
|
|
return NumberFormatter.TenPowersList[i];
|
|
}
|
|
|
|
// Token: 0x06003FEF RID: 16367 RVA: 0x000D7BBC File Offset: 0x000D5DBC
|
|
private void InitDecHexDigits(uint value)
|
|
{
|
|
if (value >= 100000000U)
|
|
{
|
|
int num = (int)(value / 100000000U);
|
|
value -= (uint)(100000000 * num);
|
|
this._val2 = NumberFormatter.FastToDecHex(num);
|
|
}
|
|
this._val1 = NumberFormatter.ToDecHex((int)value);
|
|
}
|
|
|
|
// Token: 0x06003FF0 RID: 16368 RVA: 0x000D7C00 File Offset: 0x000D5E00
|
|
private void InitDecHexDigits(ulong value)
|
|
{
|
|
if (value >= 100000000UL)
|
|
{
|
|
long num = (long)(value / 100000000UL);
|
|
value -= (ulong)(100000000L * num);
|
|
if (num >= 100000000L)
|
|
{
|
|
int num2 = (int)(num / 100000000L);
|
|
num -= (long)num2 * 100000000L;
|
|
this._val3 = NumberFormatter.ToDecHex(num2);
|
|
}
|
|
if (num != 0L)
|
|
{
|
|
this._val2 = NumberFormatter.ToDecHex((int)num);
|
|
}
|
|
}
|
|
if (value != 0UL)
|
|
{
|
|
this._val1 = NumberFormatter.ToDecHex((int)value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003FF1 RID: 16369 RVA: 0x000D7C84 File Offset: 0x000D5E84
|
|
private void InitDecHexDigits(uint hi, ulong lo)
|
|
{
|
|
if (hi == 0U)
|
|
{
|
|
this.InitDecHexDigits(lo);
|
|
return;
|
|
}
|
|
uint num = hi / 100000000U;
|
|
ulong num2 = (ulong)(hi - num * 100000000U);
|
|
ulong num3 = lo / 100000000UL;
|
|
ulong num4 = lo - num3 * 100000000UL + num2 * 9551616UL;
|
|
hi = num;
|
|
lo = num3 + num2 * 184467440737UL;
|
|
num3 = num4 / 100000000UL;
|
|
num4 -= num3 * 100000000UL;
|
|
lo += num3;
|
|
this._val1 = NumberFormatter.ToDecHex((int)num4);
|
|
num3 = lo / 100000000UL;
|
|
num4 = lo - num3 * 100000000UL;
|
|
lo = num3;
|
|
if (hi != 0U)
|
|
{
|
|
lo += (ulong)hi * 184467440737UL;
|
|
num4 += (ulong)hi * 9551616UL;
|
|
num3 = num4 / 100000000UL;
|
|
lo += num3;
|
|
num4 -= num3 * 100000000UL;
|
|
}
|
|
this._val2 = NumberFormatter.ToDecHex((int)num4);
|
|
if (lo >= 100000000UL)
|
|
{
|
|
num3 = lo / 100000000UL;
|
|
lo -= num3 * 100000000UL;
|
|
this._val4 = NumberFormatter.ToDecHex((int)num3);
|
|
}
|
|
this._val3 = NumberFormatter.ToDecHex((int)lo);
|
|
}
|
|
|
|
// Token: 0x06003FF2 RID: 16370 RVA: 0x000D7DA4 File Offset: 0x000D5FA4
|
|
private unsafe static uint FastToDecHex(int val)
|
|
{
|
|
if (val < 100)
|
|
{
|
|
return (uint)NumberFormatter.DecHexDigits[val];
|
|
}
|
|
int num = val * 5243 >> 19;
|
|
return (uint)((NumberFormatter.DecHexDigits[num] << 8) | NumberFormatter.DecHexDigits[val - num * 100]);
|
|
}
|
|
|
|
// Token: 0x06003FF3 RID: 16371 RVA: 0x000D7DEC File Offset: 0x000D5FEC
|
|
private static uint ToDecHex(int val)
|
|
{
|
|
uint num = 0U;
|
|
if (val >= 10000)
|
|
{
|
|
int num2 = val / 10000;
|
|
val -= num2 * 10000;
|
|
num = NumberFormatter.FastToDecHex(num2) << 16;
|
|
}
|
|
return num | NumberFormatter.FastToDecHex(val);
|
|
}
|
|
|
|
// Token: 0x06003FF4 RID: 16372 RVA: 0x000D7E2C File Offset: 0x000D602C
|
|
private static int FastDecHexLen(int val)
|
|
{
|
|
if (val < 256)
|
|
{
|
|
if (val < 16)
|
|
{
|
|
return 1;
|
|
}
|
|
return 2;
|
|
}
|
|
else
|
|
{
|
|
if (val < 4096)
|
|
{
|
|
return 3;
|
|
}
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003FF5 RID: 16373 RVA: 0x000D7E54 File Offset: 0x000D6054
|
|
private static int DecHexLen(uint val)
|
|
{
|
|
if (val < 65536U)
|
|
{
|
|
return NumberFormatter.FastDecHexLen((int)val);
|
|
}
|
|
return 4 + NumberFormatter.FastDecHexLen((int)(val >> 16));
|
|
}
|
|
|
|
// Token: 0x06003FF6 RID: 16374 RVA: 0x000D7E74 File Offset: 0x000D6074
|
|
private int DecHexLen()
|
|
{
|
|
if (this._val4 != 0U)
|
|
{
|
|
return NumberFormatter.DecHexLen(this._val4) + 24;
|
|
}
|
|
if (this._val3 != 0U)
|
|
{
|
|
return NumberFormatter.DecHexLen(this._val3) + 16;
|
|
}
|
|
if (this._val2 != 0U)
|
|
{
|
|
return NumberFormatter.DecHexLen(this._val2) + 8;
|
|
}
|
|
if (this._val1 != 0U)
|
|
{
|
|
return NumberFormatter.DecHexLen(this._val1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x06003FF7 RID: 16375 RVA: 0x000D7EE8 File Offset: 0x000D60E8
|
|
private static int ScaleOrder(long hi)
|
|
{
|
|
for (int i = 18; i >= 0; i--)
|
|
{
|
|
if (hi >= NumberFormatter.GetTenPowerOf(i))
|
|
{
|
|
return i + 1;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
// Token: 0x06003FF8 RID: 16376 RVA: 0x000D7F1C File Offset: 0x000D611C
|
|
private int InitialFloatingPrecision()
|
|
{
|
|
if (this._specifier == 'R')
|
|
{
|
|
return this._defPrecision + 2;
|
|
}
|
|
if (this._precision < this._defPrecision)
|
|
{
|
|
return this._defPrecision;
|
|
}
|
|
if (this._specifier == 'G')
|
|
{
|
|
return Math.Min(this._defPrecision + 2, this._precision);
|
|
}
|
|
if (this._specifier == 'E')
|
|
{
|
|
return Math.Min(this._defPrecision + 2, this._precision + 1);
|
|
}
|
|
return this._defPrecision;
|
|
}
|
|
|
|
// Token: 0x06003FF9 RID: 16377 RVA: 0x000D7FA4 File Offset: 0x000D61A4
|
|
private static int ParsePrecision(string format)
|
|
{
|
|
int num = 0;
|
|
for (int i = 1; i < format.Length; i++)
|
|
{
|
|
int num2 = (int)(format[i] - '0');
|
|
num = num * 10 + num2;
|
|
if (num2 < 0 || num2 > 9 || num > 99)
|
|
{
|
|
return -2;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06003FFA RID: 16378 RVA: 0x000D7FF8 File Offset: 0x000D61F8
|
|
private void Init(string format)
|
|
{
|
|
this._val1 = (this._val2 = (this._val3 = (this._val4 = 0U)));
|
|
this._offset = 0;
|
|
this._NaN = (this._infinity = false);
|
|
this._isCustomFormat = false;
|
|
this._specifierIsUpper = true;
|
|
this._precision = -1;
|
|
if (format == null || format.Length == 0)
|
|
{
|
|
this._specifier = 'G';
|
|
return;
|
|
}
|
|
char c = format[0];
|
|
if (c >= 'a' && c <= 'z')
|
|
{
|
|
c = c - 'a' + 'A';
|
|
this._specifierIsUpper = false;
|
|
}
|
|
else if (c < 'A' || c > 'Z')
|
|
{
|
|
this._isCustomFormat = true;
|
|
this._specifier = '0';
|
|
return;
|
|
}
|
|
this._specifier = c;
|
|
if (format.Length > 1)
|
|
{
|
|
this._precision = NumberFormatter.ParsePrecision(format);
|
|
if (this._precision == -2)
|
|
{
|
|
this._isCustomFormat = true;
|
|
this._specifier = '0';
|
|
this._precision = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003FFB RID: 16379 RVA: 0x000D80FC File Offset: 0x000D62FC
|
|
private void InitHex(ulong value)
|
|
{
|
|
int defPrecision = this._defPrecision;
|
|
switch (defPrecision)
|
|
{
|
|
case 3:
|
|
value = (ulong)((byte)value);
|
|
break;
|
|
default:
|
|
if (defPrecision == 10)
|
|
{
|
|
value = (ulong)((uint)value);
|
|
}
|
|
break;
|
|
case 5:
|
|
value = (ulong)((ushort)value);
|
|
break;
|
|
}
|
|
this._val1 = (uint)value;
|
|
this._val2 = (uint)(value >> 32);
|
|
this._decPointPos = (this._digitsLen = this.DecHexLen());
|
|
if (value == 0UL)
|
|
{
|
|
this._decPointPos = 1;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003FFC RID: 16380 RVA: 0x000D8184 File Offset: 0x000D6384
|
|
private void Init(string format, int value, int defPrecision)
|
|
{
|
|
this.Init(format);
|
|
this._defPrecision = defPrecision;
|
|
this._positive = value >= 0;
|
|
if (value == 0 || this._specifier == 'X')
|
|
{
|
|
this.InitHex((ulong)((long)value));
|
|
return;
|
|
}
|
|
if (value < 0)
|
|
{
|
|
value = -value;
|
|
}
|
|
this.InitDecHexDigits((uint)value);
|
|
this._decPointPos = (this._digitsLen = this.DecHexLen());
|
|
}
|
|
|
|
// Token: 0x06003FFD RID: 16381 RVA: 0x000D81F0 File Offset: 0x000D63F0
|
|
private void Init(string format, uint value, int defPrecision)
|
|
{
|
|
this.Init(format);
|
|
this._defPrecision = defPrecision;
|
|
this._positive = true;
|
|
if (value == 0U || this._specifier == 'X')
|
|
{
|
|
this.InitHex((ulong)value);
|
|
return;
|
|
}
|
|
this.InitDecHexDigits(value);
|
|
this._decPointPos = (this._digitsLen = this.DecHexLen());
|
|
}
|
|
|
|
// Token: 0x06003FFE RID: 16382 RVA: 0x000D824C File Offset: 0x000D644C
|
|
private void Init(string format, long value)
|
|
{
|
|
this.Init(format);
|
|
this._defPrecision = 19;
|
|
this._positive = value >= 0L;
|
|
if (value == 0L || this._specifier == 'X')
|
|
{
|
|
this.InitHex((ulong)value);
|
|
return;
|
|
}
|
|
if (value < 0L)
|
|
{
|
|
value = -value;
|
|
}
|
|
this.InitDecHexDigits((ulong)value);
|
|
this._decPointPos = (this._digitsLen = this.DecHexLen());
|
|
}
|
|
|
|
// Token: 0x06003FFF RID: 16383 RVA: 0x000D82BC File Offset: 0x000D64BC
|
|
private void Init(string format, ulong value)
|
|
{
|
|
this.Init(format);
|
|
this._defPrecision = 20;
|
|
this._positive = true;
|
|
if (value == 0UL || this._specifier == 'X')
|
|
{
|
|
this.InitHex(value);
|
|
return;
|
|
}
|
|
this.InitDecHexDigits(value);
|
|
this._decPointPos = (this._digitsLen = this.DecHexLen());
|
|
}
|
|
|
|
// Token: 0x06004000 RID: 16384 RVA: 0x000D8318 File Offset: 0x000D6518
|
|
private unsafe void Init(string format, double value, int defPrecision)
|
|
{
|
|
this.Init(format);
|
|
this._defPrecision = defPrecision;
|
|
long num = BitConverter.DoubleToInt64Bits(value);
|
|
this._positive = num >= 0L;
|
|
num &= long.MaxValue;
|
|
if (num == 0L)
|
|
{
|
|
this._decPointPos = 1;
|
|
this._digitsLen = 0;
|
|
this._positive = true;
|
|
return;
|
|
}
|
|
int num2 = (int)(num >> 52);
|
|
long num3 = num & 4503599627370495L;
|
|
if (num2 == 2047)
|
|
{
|
|
this._NaN = num3 != 0L;
|
|
this._infinity = num3 == 0L;
|
|
return;
|
|
}
|
|
int num4 = 0;
|
|
if (num2 == 0)
|
|
{
|
|
num2 = 1;
|
|
int num5 = NumberFormatter.ScaleOrder(num3);
|
|
if (num5 < 15)
|
|
{
|
|
num4 = num5 - 15;
|
|
num3 *= NumberFormatter.GetTenPowerOf(-num4);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num3 = (num3 + 4503599627370495L + 1L) * 10L;
|
|
num4 = -1;
|
|
}
|
|
ulong num6 = (ulong)((uint)num3);
|
|
ulong num7 = (ulong)num3 >> 32;
|
|
ulong num8 = NumberFormatter.MantissaBitsTable[num2];
|
|
ulong num9 = num8 >> 32;
|
|
num8 = (ulong)((uint)num8);
|
|
ulong num10 = num7 * num8 + num6 * num9 + (num6 * num8 >> 32);
|
|
long num11 = (long)(num7 * num9 + (num10 >> 32));
|
|
while (num11 < 10000000000000000L)
|
|
{
|
|
num10 = (num10 & (ulong)(-1)) * 10UL;
|
|
num11 = num11 * 10L + (long)(num10 >> 32);
|
|
num4--;
|
|
}
|
|
if ((num10 & (ulong)(-2147483648)) != 0UL)
|
|
{
|
|
num11 += 1L;
|
|
}
|
|
int num12 = 17;
|
|
this._decPointPos = NumberFormatter.TensExponentTable[num2] + num4 + num12;
|
|
int num13 = this.InitialFloatingPrecision();
|
|
if (num12 > num13)
|
|
{
|
|
long tenPowerOf = NumberFormatter.GetTenPowerOf(num12 - num13);
|
|
num11 = (num11 + (tenPowerOf >> 1)) / tenPowerOf;
|
|
num12 = num13;
|
|
}
|
|
if (num11 >= NumberFormatter.GetTenPowerOf(num12))
|
|
{
|
|
num12++;
|
|
this._decPointPos++;
|
|
}
|
|
this.InitDecHexDigits((ulong)num11);
|
|
this._offset = this.CountTrailingZeros();
|
|
this._digitsLen = num12 - this._offset;
|
|
}
|
|
|
|
// Token: 0x06004001 RID: 16385 RVA: 0x000D8508 File Offset: 0x000D6708
|
|
private void Init(string format, decimal value)
|
|
{
|
|
this.Init(format);
|
|
this._defPrecision = 100;
|
|
int[] bits = decimal.GetBits(value);
|
|
int num = (bits[3] & 2031616) >> 16;
|
|
this._positive = bits[3] >= 0;
|
|
if (bits[0] == 0 && bits[1] == 0 && bits[2] == 0)
|
|
{
|
|
this._decPointPos = -num;
|
|
this._positive = true;
|
|
this._digitsLen = 0;
|
|
return;
|
|
}
|
|
this.InitDecHexDigits((uint)bits[2], (ulong)(((long)bits[1] << 32) | (long)((ulong)bits[0])));
|
|
this._digitsLen = this.DecHexLen();
|
|
this._decPointPos = this._digitsLen - num;
|
|
if (this._precision != -1 || this._specifier != 'G')
|
|
{
|
|
this._offset = this.CountTrailingZeros();
|
|
this._digitsLen -= this._offset;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004002 RID: 16386 RVA: 0x000D85E0 File Offset: 0x000D67E0
|
|
private void ResetCharBuf(int size)
|
|
{
|
|
this._ind = 0;
|
|
if (this._cbuf.Length < size)
|
|
{
|
|
this._cbuf = new char[size];
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004003 RID: 16387 RVA: 0x000D8604 File Offset: 0x000D6804
|
|
private void Resize(int len)
|
|
{
|
|
char[] array = new char[len];
|
|
Array.Copy(this._cbuf, array, this._ind);
|
|
this._cbuf = array;
|
|
}
|
|
|
|
// Token: 0x06004004 RID: 16388 RVA: 0x000D8634 File Offset: 0x000D6834
|
|
private void Append(char c)
|
|
{
|
|
if (this._ind == this._cbuf.Length)
|
|
{
|
|
this.Resize(this._ind + 10);
|
|
}
|
|
this._cbuf[this._ind++] = c;
|
|
}
|
|
|
|
// Token: 0x06004005 RID: 16389 RVA: 0x000D867C File Offset: 0x000D687C
|
|
private void Append(char c, int cnt)
|
|
{
|
|
if (this._ind + cnt > this._cbuf.Length)
|
|
{
|
|
this.Resize(this._ind + cnt + 10);
|
|
}
|
|
while (cnt-- > 0)
|
|
{
|
|
this._cbuf[this._ind++] = c;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004006 RID: 16390 RVA: 0x000D86DC File Offset: 0x000D68DC
|
|
private void Append(string s)
|
|
{
|
|
int length = s.Length;
|
|
if (this._ind + length > this._cbuf.Length)
|
|
{
|
|
this.Resize(this._ind + length + 10);
|
|
}
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
this._cbuf[this._ind++] = s[i];
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004007 RID: 16391 RVA: 0x000D8748 File Offset: 0x000D6948
|
|
private NumberFormatInfo GetNumberFormatInstance(IFormatProvider fp)
|
|
{
|
|
if (this._nfi != null && fp == null)
|
|
{
|
|
return this._nfi;
|
|
}
|
|
return NumberFormatInfo.GetInstance(fp);
|
|
}
|
|
|
|
// Token: 0x17000BDA RID: 3034
|
|
// (set) Token: 0x06004008 RID: 16392 RVA: 0x000D8768 File Offset: 0x000D6968
|
|
public CultureInfo CurrentCulture
|
|
{
|
|
set
|
|
{
|
|
if (value != null && value.IsReadOnly)
|
|
{
|
|
this._nfi = value.NumberFormat;
|
|
}
|
|
else
|
|
{
|
|
this._nfi = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000BDB RID: 3035
|
|
// (get) Token: 0x06004009 RID: 16393 RVA: 0x000D8794 File Offset: 0x000D6994
|
|
private int IntegerDigits
|
|
{
|
|
get
|
|
{
|
|
return (this._decPointPos <= 0) ? 1 : this._decPointPos;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000BDC RID: 3036
|
|
// (get) Token: 0x0600400A RID: 16394 RVA: 0x000D87B0 File Offset: 0x000D69B0
|
|
private int DecimalDigits
|
|
{
|
|
get
|
|
{
|
|
return (this._digitsLen <= this._decPointPos) ? 0 : (this._digitsLen - this._decPointPos);
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000BDD RID: 3037
|
|
// (get) Token: 0x0600400B RID: 16395 RVA: 0x000D87E4 File Offset: 0x000D69E4
|
|
private bool IsFloatingSource
|
|
{
|
|
get
|
|
{
|
|
return this._defPrecision == 15 || this._defPrecision == 7;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000BDE RID: 3038
|
|
// (get) Token: 0x0600400C RID: 16396 RVA: 0x000D8800 File Offset: 0x000D6A00
|
|
private bool IsZero
|
|
{
|
|
get
|
|
{
|
|
return this._digitsLen == 0;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000BDF RID: 3039
|
|
// (get) Token: 0x0600400D RID: 16397 RVA: 0x000D880C File Offset: 0x000D6A0C
|
|
private bool IsZeroInteger
|
|
{
|
|
get
|
|
{
|
|
return this._digitsLen == 0 || this._decPointPos <= 0;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600400E RID: 16398 RVA: 0x000D8828 File Offset: 0x000D6A28
|
|
private void RoundPos(int pos)
|
|
{
|
|
this.RoundBits(this._digitsLen - pos);
|
|
}
|
|
|
|
// Token: 0x0600400F RID: 16399 RVA: 0x000D883C File Offset: 0x000D6A3C
|
|
private bool RoundDecimal(int decimals)
|
|
{
|
|
return this.RoundBits(this._digitsLen - this._decPointPos - decimals);
|
|
}
|
|
|
|
// Token: 0x06004010 RID: 16400 RVA: 0x000D8854 File Offset: 0x000D6A54
|
|
private bool RoundBits(int shift)
|
|
{
|
|
if (shift <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
if (shift > this._digitsLen)
|
|
{
|
|
this._digitsLen = 0;
|
|
this._decPointPos = 1;
|
|
this._val1 = (this._val2 = (this._val3 = (this._val4 = 0U)));
|
|
this._positive = true;
|
|
return false;
|
|
}
|
|
shift += this._offset;
|
|
this._digitsLen += this._offset;
|
|
while (shift > 8)
|
|
{
|
|
this._val1 = this._val2;
|
|
this._val2 = this._val3;
|
|
this._val3 = this._val4;
|
|
this._val4 = 0U;
|
|
this._digitsLen -= 8;
|
|
shift -= 8;
|
|
}
|
|
shift = shift - 1 << 2;
|
|
uint num = this._val1 >> shift;
|
|
uint num2 = num & 15U;
|
|
this._val1 = (num ^ num2) << shift;
|
|
bool flag = false;
|
|
if (num2 >= 5U)
|
|
{
|
|
this._val1 |= 2576980377U >> 28 - shift;
|
|
this.AddOneToDecHex();
|
|
int num3 = this.DecHexLen();
|
|
flag = num3 != this._digitsLen;
|
|
this._decPointPos = this._decPointPos + num3 - this._digitsLen;
|
|
this._digitsLen = num3;
|
|
}
|
|
this.RemoveTrailingZeros();
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06004011 RID: 16401 RVA: 0x000D89A8 File Offset: 0x000D6BA8
|
|
private void RemoveTrailingZeros()
|
|
{
|
|
this._offset = this.CountTrailingZeros();
|
|
this._digitsLen -= this._offset;
|
|
if (this._digitsLen == 0)
|
|
{
|
|
this._offset = 0;
|
|
this._decPointPos = 1;
|
|
this._positive = true;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004012 RID: 16402 RVA: 0x000D89F4 File Offset: 0x000D6BF4
|
|
private void AddOneToDecHex()
|
|
{
|
|
if (this._val1 == 2576980377U)
|
|
{
|
|
this._val1 = 0U;
|
|
if (this._val2 == 2576980377U)
|
|
{
|
|
this._val2 = 0U;
|
|
if (this._val3 == 2576980377U)
|
|
{
|
|
this._val3 = 0U;
|
|
this._val4 = NumberFormatter.AddOneToDecHex(this._val4);
|
|
}
|
|
else
|
|
{
|
|
this._val3 = NumberFormatter.AddOneToDecHex(this._val3);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this._val2 = NumberFormatter.AddOneToDecHex(this._val2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this._val1 = NumberFormatter.AddOneToDecHex(this._val1);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004013 RID: 16403 RVA: 0x000D8A9C File Offset: 0x000D6C9C
|
|
private static uint AddOneToDecHex(uint val)
|
|
{
|
|
if ((val & 65535U) == 39321U)
|
|
{
|
|
if ((val & 16777215U) == 10066329U)
|
|
{
|
|
if ((val & 268435455U) == 161061273U)
|
|
{
|
|
return val + 107374183U;
|
|
}
|
|
return val + 6710887U;
|
|
}
|
|
else
|
|
{
|
|
if ((val & 1048575U) == 629145U)
|
|
{
|
|
return val + 419431U;
|
|
}
|
|
return val + 26215U;
|
|
}
|
|
}
|
|
else if ((val & 255U) == 153U)
|
|
{
|
|
if ((val & 4095U) == 2457U)
|
|
{
|
|
return val + 1639U;
|
|
}
|
|
return val + 103U;
|
|
}
|
|
else
|
|
{
|
|
if ((val & 15U) == 9U)
|
|
{
|
|
return val + 7U;
|
|
}
|
|
return val + 1U;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004014 RID: 16404 RVA: 0x000D8B50 File Offset: 0x000D6D50
|
|
private int CountTrailingZeros()
|
|
{
|
|
if (this._val1 != 0U)
|
|
{
|
|
return NumberFormatter.CountTrailingZeros(this._val1);
|
|
}
|
|
if (this._val2 != 0U)
|
|
{
|
|
return NumberFormatter.CountTrailingZeros(this._val2) + 8;
|
|
}
|
|
if (this._val3 != 0U)
|
|
{
|
|
return NumberFormatter.CountTrailingZeros(this._val3) + 16;
|
|
}
|
|
if (this._val4 != 0U)
|
|
{
|
|
return NumberFormatter.CountTrailingZeros(this._val4) + 24;
|
|
}
|
|
return this._digitsLen;
|
|
}
|
|
|
|
// Token: 0x06004015 RID: 16405 RVA: 0x000D8BC8 File Offset: 0x000D6DC8
|
|
private static int CountTrailingZeros(uint val)
|
|
{
|
|
if ((val & 65535U) == 0U)
|
|
{
|
|
if ((val & 16777215U) == 0U)
|
|
{
|
|
if ((val & 268435455U) == 0U)
|
|
{
|
|
return 7;
|
|
}
|
|
return 6;
|
|
}
|
|
else
|
|
{
|
|
if ((val & 1048575U) == 0U)
|
|
{
|
|
return 5;
|
|
}
|
|
return 4;
|
|
}
|
|
}
|
|
else if ((val & 255U) == 0U)
|
|
{
|
|
if ((val & 4095U) == 0U)
|
|
{
|
|
return 3;
|
|
}
|
|
return 2;
|
|
}
|
|
else
|
|
{
|
|
if ((val & 15U) == 0U)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004016 RID: 16406 RVA: 0x000D8C38 File Offset: 0x000D6E38
|
|
private static NumberFormatter GetInstance()
|
|
{
|
|
NumberFormatter numberFormatter = NumberFormatter.threadNumberFormatter;
|
|
NumberFormatter.threadNumberFormatter = null;
|
|
if (numberFormatter == null)
|
|
{
|
|
return new NumberFormatter(Thread.CurrentThread);
|
|
}
|
|
return numberFormatter;
|
|
}
|
|
|
|
// Token: 0x06004017 RID: 16407 RVA: 0x000D8C64 File Offset: 0x000D6E64
|
|
private void Release()
|
|
{
|
|
NumberFormatter.threadNumberFormatter = this;
|
|
}
|
|
|
|
// Token: 0x06004018 RID: 16408 RVA: 0x000D8C6C File Offset: 0x000D6E6C
|
|
internal static void SetThreadCurrentCulture(CultureInfo culture)
|
|
{
|
|
if (NumberFormatter.threadNumberFormatter != null)
|
|
{
|
|
NumberFormatter.threadNumberFormatter.CurrentCulture = culture;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004019 RID: 16409 RVA: 0x000D8C84 File Offset: 0x000D6E84
|
|
public static string NumberToString(string format, sbyte value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, (int)value, 3);
|
|
string text = instance.IntegerToString(format, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x0600401A RID: 16410 RVA: 0x000D8CB4 File Offset: 0x000D6EB4
|
|
public static string NumberToString(string format, byte value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, (int)value, 3);
|
|
string text = instance.IntegerToString(format, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x0600401B RID: 16411 RVA: 0x000D8CE0 File Offset: 0x000D6EE0
|
|
public static string NumberToString(string format, ushort value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, (int)value, 5);
|
|
string text = instance.IntegerToString(format, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x0600401C RID: 16412 RVA: 0x000D8D0C File Offset: 0x000D6F0C
|
|
public static string NumberToString(string format, short value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, (int)value, 5);
|
|
string text = instance.IntegerToString(format, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x0600401D RID: 16413 RVA: 0x000D8D38 File Offset: 0x000D6F38
|
|
public static string NumberToString(string format, uint value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, value, 10);
|
|
string text = instance.IntegerToString(format, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x0600401E RID: 16414 RVA: 0x000D8D68 File Offset: 0x000D6F68
|
|
public static string NumberToString(string format, int value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, value, 10);
|
|
string text = instance.IntegerToString(format, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x0600401F RID: 16415 RVA: 0x000D8D98 File Offset: 0x000D6F98
|
|
public static string NumberToString(string format, ulong value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, value);
|
|
string text = instance.IntegerToString(format, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06004020 RID: 16416 RVA: 0x000D8DC4 File Offset: 0x000D6FC4
|
|
public static string NumberToString(string format, long value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, value);
|
|
string text = instance.IntegerToString(format, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06004021 RID: 16417 RVA: 0x000D8DF0 File Offset: 0x000D6FF0
|
|
public static string NumberToString(string format, float value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, (double)value, 7);
|
|
NumberFormatInfo numberFormatInstance = instance.GetNumberFormatInstance(fp);
|
|
string text;
|
|
if (instance._NaN)
|
|
{
|
|
text = numberFormatInstance.NaNSymbol;
|
|
}
|
|
else if (instance._infinity)
|
|
{
|
|
if (instance._positive)
|
|
{
|
|
text = numberFormatInstance.PositiveInfinitySymbol;
|
|
}
|
|
else
|
|
{
|
|
text = numberFormatInstance.NegativeInfinitySymbol;
|
|
}
|
|
}
|
|
else if (instance._specifier == 'R')
|
|
{
|
|
text = instance.FormatRoundtrip(value, numberFormatInstance);
|
|
}
|
|
else
|
|
{
|
|
text = instance.NumberToString(format, numberFormatInstance);
|
|
}
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06004022 RID: 16418 RVA: 0x000D8E88 File Offset: 0x000D7088
|
|
public static string NumberToString(string format, double value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, value, 15);
|
|
NumberFormatInfo numberFormatInstance = instance.GetNumberFormatInstance(fp);
|
|
string text;
|
|
if (instance._NaN)
|
|
{
|
|
text = numberFormatInstance.NaNSymbol;
|
|
}
|
|
else if (instance._infinity)
|
|
{
|
|
if (instance._positive)
|
|
{
|
|
text = numberFormatInstance.PositiveInfinitySymbol;
|
|
}
|
|
else
|
|
{
|
|
text = numberFormatInstance.NegativeInfinitySymbol;
|
|
}
|
|
}
|
|
else if (instance._specifier == 'R')
|
|
{
|
|
text = instance.FormatRoundtrip(value, numberFormatInstance);
|
|
}
|
|
else
|
|
{
|
|
text = instance.NumberToString(format, numberFormatInstance);
|
|
}
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06004023 RID: 16419 RVA: 0x000D8F20 File Offset: 0x000D7120
|
|
public static string NumberToString(string format, decimal value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(format, value);
|
|
string text = instance.NumberToString(format, instance.GetNumberFormatInstance(fp));
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06004024 RID: 16420 RVA: 0x000D8F54 File Offset: 0x000D7154
|
|
public static string NumberToString(uint value, IFormatProvider fp)
|
|
{
|
|
if (value >= 100000000U)
|
|
{
|
|
return NumberFormatter.NumberToString(null, value, fp);
|
|
}
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
string text = instance.FastIntegerToString((int)value, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06004025 RID: 16421 RVA: 0x000D8F8C File Offset: 0x000D718C
|
|
public static string NumberToString(int value, IFormatProvider fp)
|
|
{
|
|
if (value >= 100000000 || value <= -100000000)
|
|
{
|
|
return NumberFormatter.NumberToString(null, value, fp);
|
|
}
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
string text = instance.FastIntegerToString(value, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06004026 RID: 16422 RVA: 0x000D8FD0 File Offset: 0x000D71D0
|
|
public static string NumberToString(ulong value, IFormatProvider fp)
|
|
{
|
|
if (value >= 100000000UL)
|
|
{
|
|
return NumberFormatter.NumberToString(null, value, fp);
|
|
}
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
string text = instance.FastIntegerToString((int)value, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06004027 RID: 16423 RVA: 0x000D900C File Offset: 0x000D720C
|
|
public static string NumberToString(long value, IFormatProvider fp)
|
|
{
|
|
if (value >= 100000000L || value <= -100000000L)
|
|
{
|
|
return NumberFormatter.NumberToString(null, value, fp);
|
|
}
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
string text = instance.FastIntegerToString((int)value, fp);
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06004028 RID: 16424 RVA: 0x000D9054 File Offset: 0x000D7254
|
|
public static string NumberToString(float value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
instance.Init(null, (double)value, 7);
|
|
NumberFormatInfo numberFormatInstance = instance.GetNumberFormatInstance(fp);
|
|
string text;
|
|
if (instance._NaN)
|
|
{
|
|
text = numberFormatInstance.NaNSymbol;
|
|
}
|
|
else if (instance._infinity)
|
|
{
|
|
if (instance._positive)
|
|
{
|
|
text = numberFormatInstance.PositiveInfinitySymbol;
|
|
}
|
|
else
|
|
{
|
|
text = numberFormatInstance.NegativeInfinitySymbol;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
text = instance.FormatGeneral(-1, numberFormatInstance);
|
|
}
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06004029 RID: 16425 RVA: 0x000D90D0 File Offset: 0x000D72D0
|
|
public static string NumberToString(double value, IFormatProvider fp)
|
|
{
|
|
NumberFormatter instance = NumberFormatter.GetInstance();
|
|
NumberFormatInfo numberFormatInstance = instance.GetNumberFormatInstance(fp);
|
|
instance.Init(null, value, 15);
|
|
string text;
|
|
if (instance._NaN)
|
|
{
|
|
text = numberFormatInstance.NaNSymbol;
|
|
}
|
|
else if (instance._infinity)
|
|
{
|
|
if (instance._positive)
|
|
{
|
|
text = numberFormatInstance.PositiveInfinitySymbol;
|
|
}
|
|
else
|
|
{
|
|
text = numberFormatInstance.NegativeInfinitySymbol;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
text = instance.FormatGeneral(-1, numberFormatInstance);
|
|
}
|
|
instance.Release();
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x0600402A RID: 16426 RVA: 0x000D914C File Offset: 0x000D734C
|
|
private string FastIntegerToString(int value, IFormatProvider fp)
|
|
{
|
|
if (value < 0)
|
|
{
|
|
string negativeSign = this.GetNumberFormatInstance(fp).NegativeSign;
|
|
this.ResetCharBuf(8 + negativeSign.Length);
|
|
value = -value;
|
|
this.Append(negativeSign);
|
|
}
|
|
else
|
|
{
|
|
this.ResetCharBuf(8);
|
|
}
|
|
if (value >= 10000)
|
|
{
|
|
int num = value / 10000;
|
|
this.FastAppendDigits(num, false);
|
|
this.FastAppendDigits(value - num * 10000, true);
|
|
}
|
|
else
|
|
{
|
|
this.FastAppendDigits(value, false);
|
|
}
|
|
return new string(this._cbuf, 0, this._ind);
|
|
}
|
|
|
|
// Token: 0x0600402B RID: 16427 RVA: 0x000D91DC File Offset: 0x000D73DC
|
|
private string IntegerToString(string format, IFormatProvider fp)
|
|
{
|
|
NumberFormatInfo numberFormatInstance = this.GetNumberFormatInstance(fp);
|
|
char specifier = this._specifier;
|
|
switch (specifier)
|
|
{
|
|
case 'C':
|
|
return this.FormatCurrency(this._precision, numberFormatInstance);
|
|
case 'D':
|
|
return this.FormatDecimal(this._precision, numberFormatInstance);
|
|
case 'E':
|
|
return this.FormatExponential(this._precision, numberFormatInstance);
|
|
case 'F':
|
|
return this.FormatFixedPoint(this._precision, numberFormatInstance);
|
|
case 'G':
|
|
if (this._precision <= 0)
|
|
{
|
|
return this.FormatDecimal(-1, numberFormatInstance);
|
|
}
|
|
return this.FormatGeneral(this._precision, numberFormatInstance);
|
|
default:
|
|
if (specifier == 'X')
|
|
{
|
|
return this.FormatHexadecimal(this._precision);
|
|
}
|
|
if (this._isCustomFormat)
|
|
{
|
|
return this.FormatCustom(format, numberFormatInstance);
|
|
}
|
|
throw new FormatException("The specified format '" + format + "' is invalid");
|
|
case 'N':
|
|
return this.FormatNumber(this._precision, numberFormatInstance);
|
|
case 'P':
|
|
return this.FormatPercent(this._precision, numberFormatInstance);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600402C RID: 16428 RVA: 0x000D92F4 File Offset: 0x000D74F4
|
|
private string NumberToString(string format, NumberFormatInfo nfi)
|
|
{
|
|
char specifier = this._specifier;
|
|
switch (specifier)
|
|
{
|
|
case 'C':
|
|
return this.FormatCurrency(this._precision, nfi);
|
|
default:
|
|
switch (specifier)
|
|
{
|
|
case 'N':
|
|
return this.FormatNumber(this._precision, nfi);
|
|
default:
|
|
if (specifier != 'X')
|
|
{
|
|
}
|
|
if (this._isCustomFormat)
|
|
{
|
|
return this.FormatCustom(format, nfi);
|
|
}
|
|
throw new FormatException("The specified format '" + format + "' is invalid");
|
|
case 'P':
|
|
return this.FormatPercent(this._precision, nfi);
|
|
}
|
|
break;
|
|
case 'E':
|
|
return this.FormatExponential(this._precision, nfi);
|
|
case 'F':
|
|
return this.FormatFixedPoint(this._precision, nfi);
|
|
case 'G':
|
|
return this.FormatGeneral(this._precision, nfi);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600402D RID: 16429 RVA: 0x000D93C4 File Offset: 0x000D75C4
|
|
public string FormatCurrency(int precision, NumberFormatInfo nfi)
|
|
{
|
|
precision = ((precision < 0) ? nfi.CurrencyDecimalDigits : precision);
|
|
this.RoundDecimal(precision);
|
|
this.ResetCharBuf(this.IntegerDigits * 2 + precision * 2 + 16);
|
|
if (this._positive)
|
|
{
|
|
switch (nfi.CurrencyPositivePattern)
|
|
{
|
|
case 0:
|
|
this.Append(nfi.CurrencySymbol);
|
|
break;
|
|
case 2:
|
|
this.Append(nfi.CurrencySymbol);
|
|
this.Append(' ');
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (nfi.CurrencyNegativePattern)
|
|
{
|
|
case 0:
|
|
this.Append('(');
|
|
this.Append(nfi.CurrencySymbol);
|
|
break;
|
|
case 1:
|
|
this.Append(nfi.NegativeSign);
|
|
this.Append(nfi.CurrencySymbol);
|
|
break;
|
|
case 2:
|
|
this.Append(nfi.CurrencySymbol);
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 3:
|
|
this.Append(nfi.CurrencySymbol);
|
|
break;
|
|
case 4:
|
|
this.Append('(');
|
|
break;
|
|
case 5:
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 8:
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 9:
|
|
this.Append(nfi.NegativeSign);
|
|
this.Append(nfi.CurrencySymbol);
|
|
this.Append(' ');
|
|
break;
|
|
case 11:
|
|
this.Append(nfi.CurrencySymbol);
|
|
this.Append(' ');
|
|
break;
|
|
case 12:
|
|
this.Append(nfi.CurrencySymbol);
|
|
this.Append(' ');
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 14:
|
|
this.Append('(');
|
|
this.Append(nfi.CurrencySymbol);
|
|
this.Append(' ');
|
|
break;
|
|
case 15:
|
|
this.Append('(');
|
|
break;
|
|
}
|
|
}
|
|
this.AppendIntegerStringWithGroupSeparator(nfi.RawCurrencyGroupSizes, nfi.CurrencyGroupSeparator);
|
|
if (precision > 0)
|
|
{
|
|
this.Append(nfi.CurrencyDecimalSeparator);
|
|
this.AppendDecimalString(precision);
|
|
}
|
|
if (this._positive)
|
|
{
|
|
switch (nfi.CurrencyPositivePattern)
|
|
{
|
|
case 1:
|
|
this.Append(nfi.CurrencySymbol);
|
|
break;
|
|
case 3:
|
|
this.Append(' ');
|
|
this.Append(nfi.CurrencySymbol);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (nfi.CurrencyNegativePattern)
|
|
{
|
|
case 0:
|
|
this.Append(')');
|
|
break;
|
|
case 3:
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 4:
|
|
this.Append(nfi.CurrencySymbol);
|
|
this.Append(')');
|
|
break;
|
|
case 5:
|
|
this.Append(nfi.CurrencySymbol);
|
|
break;
|
|
case 6:
|
|
this.Append(nfi.NegativeSign);
|
|
this.Append(nfi.CurrencySymbol);
|
|
break;
|
|
case 7:
|
|
this.Append(nfi.CurrencySymbol);
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 8:
|
|
this.Append(' ');
|
|
this.Append(nfi.CurrencySymbol);
|
|
break;
|
|
case 10:
|
|
this.Append(' ');
|
|
this.Append(nfi.CurrencySymbol);
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 11:
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 13:
|
|
this.Append(nfi.NegativeSign);
|
|
this.Append(' ');
|
|
this.Append(nfi.CurrencySymbol);
|
|
break;
|
|
case 14:
|
|
this.Append(')');
|
|
break;
|
|
case 15:
|
|
this.Append(' ');
|
|
this.Append(nfi.CurrencySymbol);
|
|
this.Append(')');
|
|
break;
|
|
}
|
|
}
|
|
return new string(this._cbuf, 0, this._ind);
|
|
}
|
|
|
|
// Token: 0x0600402E RID: 16430 RVA: 0x000D97E0 File Offset: 0x000D79E0
|
|
private string FormatDecimal(int precision, NumberFormatInfo nfi)
|
|
{
|
|
if (precision < this._digitsLen)
|
|
{
|
|
precision = this._digitsLen;
|
|
}
|
|
if (precision == 0)
|
|
{
|
|
return "0";
|
|
}
|
|
this.ResetCharBuf(precision + 1);
|
|
if (!this._positive)
|
|
{
|
|
this.Append(nfi.NegativeSign);
|
|
}
|
|
this.AppendDigits(0, precision);
|
|
return new string(this._cbuf, 0, this._ind);
|
|
}
|
|
|
|
// Token: 0x0600402F RID: 16431 RVA: 0x000D9848 File Offset: 0x000D7A48
|
|
private unsafe string FormatHexadecimal(int precision)
|
|
{
|
|
int i = Math.Max(precision, this._decPointPos);
|
|
char* ptr = ((!this._specifierIsUpper) ? NumberFormatter.DigitLowerTable : NumberFormatter.DigitUpperTable);
|
|
this.ResetCharBuf(i);
|
|
this._ind = i;
|
|
ulong num = (ulong)this._val1 | ((ulong)this._val2 << 32);
|
|
while (i > 0)
|
|
{
|
|
this._cbuf[--i] = ptr[(num & 15UL) * 2UL / 2UL];
|
|
num >>= 4;
|
|
}
|
|
return new string(this._cbuf, 0, this._ind);
|
|
}
|
|
|
|
// Token: 0x06004030 RID: 16432 RVA: 0x000D98D8 File Offset: 0x000D7AD8
|
|
public string FormatFixedPoint(int precision, NumberFormatInfo nfi)
|
|
{
|
|
if (precision == -1)
|
|
{
|
|
precision = nfi.NumberDecimalDigits;
|
|
}
|
|
this.RoundDecimal(precision);
|
|
this.ResetCharBuf(this.IntegerDigits + precision + 2);
|
|
if (!this._positive)
|
|
{
|
|
this.Append(nfi.NegativeSign);
|
|
}
|
|
this.AppendIntegerString(this.IntegerDigits);
|
|
if (precision > 0)
|
|
{
|
|
this.Append(nfi.NumberDecimalSeparator);
|
|
this.AppendDecimalString(precision);
|
|
}
|
|
return new string(this._cbuf, 0, this._ind);
|
|
}
|
|
|
|
// Token: 0x06004031 RID: 16433 RVA: 0x000D995C File Offset: 0x000D7B5C
|
|
private string FormatRoundtrip(double origval, NumberFormatInfo nfi)
|
|
{
|
|
NumberFormatter clone = this.GetClone();
|
|
if (origval >= -1.79769313486231E+308 && origval <= 1.79769313486231E+308)
|
|
{
|
|
string text = this.FormatGeneral(this._defPrecision, nfi);
|
|
if (origval == double.Parse(text, nfi))
|
|
{
|
|
return text;
|
|
}
|
|
}
|
|
return clone.FormatGeneral(this._defPrecision + 2, nfi);
|
|
}
|
|
|
|
// Token: 0x06004032 RID: 16434 RVA: 0x000D99BC File Offset: 0x000D7BBC
|
|
private string FormatRoundtrip(float origval, NumberFormatInfo nfi)
|
|
{
|
|
NumberFormatter clone = this.GetClone();
|
|
string text = this.FormatGeneral(this._defPrecision, nfi);
|
|
if (origval == float.Parse(text, nfi))
|
|
{
|
|
return text;
|
|
}
|
|
return clone.FormatGeneral(this._defPrecision + 2, nfi);
|
|
}
|
|
|
|
// Token: 0x06004033 RID: 16435 RVA: 0x000D99FC File Offset: 0x000D7BFC
|
|
private string FormatGeneral(int precision, NumberFormatInfo nfi)
|
|
{
|
|
bool flag;
|
|
if (precision == -1)
|
|
{
|
|
flag = this.IsFloatingSource;
|
|
precision = this._defPrecision;
|
|
}
|
|
else
|
|
{
|
|
flag = true;
|
|
if (precision == 0)
|
|
{
|
|
precision = this._defPrecision;
|
|
}
|
|
this.RoundPos(precision);
|
|
}
|
|
int num = this._decPointPos;
|
|
int digitsLen = this._digitsLen;
|
|
int num2 = digitsLen - num;
|
|
if ((num > precision || num <= -4) && flag)
|
|
{
|
|
return this.FormatExponential(digitsLen - 1, nfi, 2);
|
|
}
|
|
if (num2 < 0)
|
|
{
|
|
num2 = 0;
|
|
}
|
|
if (num < 0)
|
|
{
|
|
num = 0;
|
|
}
|
|
this.ResetCharBuf(num2 + num + 3);
|
|
if (!this._positive)
|
|
{
|
|
this.Append(nfi.NegativeSign);
|
|
}
|
|
if (num == 0)
|
|
{
|
|
this.Append('0');
|
|
}
|
|
else
|
|
{
|
|
this.AppendDigits(digitsLen - num, digitsLen);
|
|
}
|
|
if (num2 > 0)
|
|
{
|
|
this.Append(nfi.NumberDecimalSeparator);
|
|
this.AppendDigits(0, num2);
|
|
}
|
|
return new string(this._cbuf, 0, this._ind);
|
|
}
|
|
|
|
// Token: 0x06004034 RID: 16436 RVA: 0x000D9AEC File Offset: 0x000D7CEC
|
|
public string FormatNumber(int precision, NumberFormatInfo nfi)
|
|
{
|
|
precision = ((precision < 0) ? nfi.NumberDecimalDigits : precision);
|
|
this.ResetCharBuf(this.IntegerDigits * 3 + precision);
|
|
this.RoundDecimal(precision);
|
|
if (!this._positive)
|
|
{
|
|
switch (nfi.NumberNegativePattern)
|
|
{
|
|
case 0:
|
|
this.Append('(');
|
|
break;
|
|
case 1:
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 2:
|
|
this.Append(nfi.NegativeSign);
|
|
this.Append(' ');
|
|
break;
|
|
}
|
|
}
|
|
this.AppendIntegerStringWithGroupSeparator(nfi.RawNumberGroupSizes, nfi.NumberGroupSeparator);
|
|
if (precision > 0)
|
|
{
|
|
this.Append(nfi.NumberDecimalSeparator);
|
|
this.AppendDecimalString(precision);
|
|
}
|
|
if (!this._positive)
|
|
{
|
|
switch (nfi.NumberNegativePattern)
|
|
{
|
|
case 0:
|
|
this.Append(')');
|
|
break;
|
|
case 3:
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 4:
|
|
this.Append(' ');
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
}
|
|
}
|
|
return new string(this._cbuf, 0, this._ind);
|
|
}
|
|
|
|
// Token: 0x06004035 RID: 16437 RVA: 0x000D9C2C File Offset: 0x000D7E2C
|
|
public string FormatPercent(int precision, NumberFormatInfo nfi)
|
|
{
|
|
precision = ((precision < 0) ? nfi.PercentDecimalDigits : precision);
|
|
this.Multiply10(2);
|
|
this.RoundDecimal(precision);
|
|
this.ResetCharBuf(this.IntegerDigits * 2 + precision + 16);
|
|
if (this._positive)
|
|
{
|
|
if (nfi.PercentPositivePattern == 2)
|
|
{
|
|
this.Append(nfi.PercentSymbol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (nfi.PercentNegativePattern)
|
|
{
|
|
case 0:
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 1:
|
|
this.Append(nfi.NegativeSign);
|
|
break;
|
|
case 2:
|
|
this.Append(nfi.NegativeSign);
|
|
this.Append(nfi.PercentSymbol);
|
|
break;
|
|
}
|
|
}
|
|
this.AppendIntegerStringWithGroupSeparator(nfi.RawPercentGroupSizes, nfi.PercentGroupSeparator);
|
|
if (precision > 0)
|
|
{
|
|
this.Append(nfi.PercentDecimalSeparator);
|
|
this.AppendDecimalString(precision);
|
|
}
|
|
if (this._positive)
|
|
{
|
|
int num = nfi.PercentPositivePattern;
|
|
if (num != 0)
|
|
{
|
|
if (num == 1)
|
|
{
|
|
this.Append(nfi.PercentSymbol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.Append(' ');
|
|
this.Append(nfi.PercentSymbol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int num = nfi.PercentNegativePattern;
|
|
if (num != 0)
|
|
{
|
|
if (num == 1)
|
|
{
|
|
this.Append(nfi.PercentSymbol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.Append(' ');
|
|
this.Append(nfi.PercentSymbol);
|
|
}
|
|
}
|
|
return new string(this._cbuf, 0, this._ind);
|
|
}
|
|
|
|
// Token: 0x06004036 RID: 16438 RVA: 0x000D9DCC File Offset: 0x000D7FCC
|
|
public string FormatExponential(int precision, NumberFormatInfo nfi)
|
|
{
|
|
if (precision == -1)
|
|
{
|
|
precision = 6;
|
|
}
|
|
this.RoundPos(precision + 1);
|
|
return this.FormatExponential(precision, nfi, 3);
|
|
}
|
|
|
|
// Token: 0x06004037 RID: 16439 RVA: 0x000D9DEC File Offset: 0x000D7FEC
|
|
private string FormatExponential(int precision, NumberFormatInfo nfi, int expDigits)
|
|
{
|
|
int decPointPos = this._decPointPos;
|
|
int digitsLen = this._digitsLen;
|
|
int num = decPointPos - 1;
|
|
int num2 = (this._decPointPos = 1);
|
|
this.ResetCharBuf(precision + 8);
|
|
if (!this._positive)
|
|
{
|
|
this.Append(nfi.NegativeSign);
|
|
}
|
|
this.AppendOneDigit(digitsLen - 1);
|
|
if (precision > 0)
|
|
{
|
|
this.Append(nfi.NumberDecimalSeparator);
|
|
this.AppendDigits(digitsLen - precision - 1, digitsLen - this._decPointPos);
|
|
}
|
|
this.AppendExponent(nfi, num, expDigits);
|
|
return new string(this._cbuf, 0, this._ind);
|
|
}
|
|
|
|
// Token: 0x06004038 RID: 16440 RVA: 0x000D9E80 File Offset: 0x000D8080
|
|
public string FormatCustom(string format, NumberFormatInfo nfi)
|
|
{
|
|
bool positive = this._positive;
|
|
int num = 0;
|
|
int num2 = 0;
|
|
NumberFormatter.CustomInfo.GetActiveSection(format, ref positive, this.IsZero, ref num, ref num2);
|
|
if (num2 == 0)
|
|
{
|
|
return (!this._positive) ? nfi.NegativeSign : string.Empty;
|
|
}
|
|
this._positive = positive;
|
|
NumberFormatter.CustomInfo customInfo = NumberFormatter.CustomInfo.Parse(format, num, num2, nfi);
|
|
StringBuilder stringBuilder = new StringBuilder(customInfo.IntegerDigits * 2);
|
|
StringBuilder stringBuilder2 = new StringBuilder(customInfo.DecimalDigits * 2);
|
|
StringBuilder stringBuilder3 = ((!customInfo.UseExponent) ? null : new StringBuilder(customInfo.ExponentDigits * 2));
|
|
int num3 = 0;
|
|
if (customInfo.Percents > 0)
|
|
{
|
|
this.Multiply10(2 * customInfo.Percents);
|
|
}
|
|
if (customInfo.Permilles > 0)
|
|
{
|
|
this.Multiply10(3 * customInfo.Permilles);
|
|
}
|
|
if (customInfo.DividePlaces > 0)
|
|
{
|
|
this.Divide10(customInfo.DividePlaces);
|
|
}
|
|
bool flag = true;
|
|
if (customInfo.UseExponent && (customInfo.DecimalDigits > 0 || customInfo.IntegerDigits > 0))
|
|
{
|
|
if (!this.IsZero)
|
|
{
|
|
this.RoundPos(customInfo.DecimalDigits + customInfo.IntegerDigits);
|
|
num3 -= this._decPointPos - customInfo.IntegerDigits;
|
|
this._decPointPos = customInfo.IntegerDigits;
|
|
}
|
|
flag = num3 <= 0;
|
|
NumberFormatter.AppendNonNegativeNumber(stringBuilder3, (num3 >= 0) ? num3 : (-num3));
|
|
}
|
|
else
|
|
{
|
|
this.RoundDecimal(customInfo.DecimalDigits);
|
|
}
|
|
if (customInfo.IntegerDigits != 0 || !this.IsZeroInteger)
|
|
{
|
|
this.AppendIntegerString(this.IntegerDigits, stringBuilder);
|
|
}
|
|
this.AppendDecimalString(this.DecimalDigits, stringBuilder2);
|
|
if (customInfo.UseExponent)
|
|
{
|
|
if (customInfo.DecimalDigits <= 0 && customInfo.IntegerDigits <= 0)
|
|
{
|
|
this._positive = true;
|
|
}
|
|
if (stringBuilder.Length < customInfo.IntegerDigits)
|
|
{
|
|
stringBuilder.Insert(0, "0", customInfo.IntegerDigits - stringBuilder.Length);
|
|
}
|
|
while (stringBuilder3.Length < customInfo.ExponentDigits - customInfo.ExponentTailSharpDigits)
|
|
{
|
|
stringBuilder3.Insert(0, '0');
|
|
}
|
|
if (flag && !customInfo.ExponentNegativeSignOnly)
|
|
{
|
|
stringBuilder3.Insert(0, nfi.PositiveSign);
|
|
}
|
|
else if (!flag)
|
|
{
|
|
stringBuilder3.Insert(0, nfi.NegativeSign);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (stringBuilder.Length < customInfo.IntegerDigits - customInfo.IntegerHeadSharpDigits)
|
|
{
|
|
stringBuilder.Insert(0, "0", customInfo.IntegerDigits - customInfo.IntegerHeadSharpDigits - stringBuilder.Length);
|
|
}
|
|
if (customInfo.IntegerDigits == customInfo.IntegerHeadSharpDigits && NumberFormatter.IsZeroOnly(stringBuilder))
|
|
{
|
|
stringBuilder.Remove(0, stringBuilder.Length);
|
|
}
|
|
}
|
|
NumberFormatter.ZeroTrimEnd(stringBuilder2, true);
|
|
while (stringBuilder2.Length < customInfo.DecimalDigits - customInfo.DecimalTailSharpDigits)
|
|
{
|
|
stringBuilder2.Append('0');
|
|
}
|
|
if (stringBuilder2.Length > customInfo.DecimalDigits)
|
|
{
|
|
stringBuilder2.Remove(customInfo.DecimalDigits, stringBuilder2.Length - customInfo.DecimalDigits);
|
|
}
|
|
return customInfo.Format(format, num, num2, nfi, this._positive, stringBuilder, stringBuilder2, stringBuilder3);
|
|
}
|
|
|
|
// Token: 0x06004039 RID: 16441 RVA: 0x000DA1D4 File Offset: 0x000D83D4
|
|
private static void ZeroTrimEnd(StringBuilder sb, bool canEmpty)
|
|
{
|
|
int num = 0;
|
|
int num2 = sb.Length - 1;
|
|
while ((!canEmpty) ? (num2 > 0) : (num2 >= 0))
|
|
{
|
|
if (sb[num2] != '0')
|
|
{
|
|
break;
|
|
}
|
|
num++;
|
|
num2--;
|
|
}
|
|
if (num > 0)
|
|
{
|
|
sb.Remove(sb.Length - num, num);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600403A RID: 16442 RVA: 0x000DA240 File Offset: 0x000D8440
|
|
private static bool IsZeroOnly(StringBuilder sb)
|
|
{
|
|
for (int i = 0; i < sb.Length; i++)
|
|
{
|
|
if (char.IsDigit(sb[i]) && sb[i] != '0')
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x0600403B RID: 16443 RVA: 0x000DA288 File Offset: 0x000D8488
|
|
private static void AppendNonNegativeNumber(StringBuilder sb, int v)
|
|
{
|
|
if (v < 0)
|
|
{
|
|
throw new ArgumentException();
|
|
}
|
|
int num = NumberFormatter.ScaleOrder((long)v) - 1;
|
|
do
|
|
{
|
|
int num2 = v / (int)NumberFormatter.GetTenPowerOf(num);
|
|
sb.Append((char)(48 | num2));
|
|
v -= (int)NumberFormatter.GetTenPowerOf(num--) * num2;
|
|
}
|
|
while (num >= 0);
|
|
}
|
|
|
|
// Token: 0x0600403C RID: 16444 RVA: 0x000DA2DC File Offset: 0x000D84DC
|
|
private void AppendIntegerString(int minLength, StringBuilder sb)
|
|
{
|
|
if (this._decPointPos <= 0)
|
|
{
|
|
sb.Append('0', minLength);
|
|
return;
|
|
}
|
|
if (this._decPointPos < minLength)
|
|
{
|
|
sb.Append('0', minLength - this._decPointPos);
|
|
}
|
|
this.AppendDigits(this._digitsLen - this._decPointPos, this._digitsLen, sb);
|
|
}
|
|
|
|
// Token: 0x0600403D RID: 16445 RVA: 0x000DA338 File Offset: 0x000D8538
|
|
private void AppendIntegerString(int minLength)
|
|
{
|
|
if (this._decPointPos <= 0)
|
|
{
|
|
this.Append('0', minLength);
|
|
return;
|
|
}
|
|
if (this._decPointPos < minLength)
|
|
{
|
|
this.Append('0', minLength - this._decPointPos);
|
|
}
|
|
this.AppendDigits(this._digitsLen - this._decPointPos, this._digitsLen);
|
|
}
|
|
|
|
// Token: 0x0600403E RID: 16446 RVA: 0x000DA390 File Offset: 0x000D8590
|
|
private void AppendDecimalString(int precision, StringBuilder sb)
|
|
{
|
|
this.AppendDigits(this._digitsLen - precision - this._decPointPos, this._digitsLen - this._decPointPos, sb);
|
|
}
|
|
|
|
// Token: 0x0600403F RID: 16447 RVA: 0x000DA3B8 File Offset: 0x000D85B8
|
|
private void AppendDecimalString(int precision)
|
|
{
|
|
this.AppendDigits(this._digitsLen - precision - this._decPointPos, this._digitsLen - this._decPointPos);
|
|
}
|
|
|
|
// Token: 0x06004040 RID: 16448 RVA: 0x000DA3E8 File Offset: 0x000D85E8
|
|
private void AppendIntegerStringWithGroupSeparator(int[] groups, string groupSeparator)
|
|
{
|
|
if (this.IsZeroInteger)
|
|
{
|
|
this.Append('0');
|
|
return;
|
|
}
|
|
int num = 0;
|
|
int num2 = 0;
|
|
for (int i = 0; i < groups.Length; i++)
|
|
{
|
|
num += groups[i];
|
|
if (num > this._decPointPos)
|
|
{
|
|
break;
|
|
}
|
|
num2 = i;
|
|
}
|
|
if (groups.Length > 0 && num > 0)
|
|
{
|
|
int num3 = groups[num2];
|
|
int num4 = ((this._decPointPos <= num) ? 0 : (this._decPointPos - num));
|
|
if (num3 == 0)
|
|
{
|
|
while (num2 >= 0 && groups[num2] == 0)
|
|
{
|
|
num2--;
|
|
}
|
|
num3 = ((num4 <= 0) ? groups[num2] : num4);
|
|
}
|
|
int num5;
|
|
if (num4 == 0)
|
|
{
|
|
num5 = num3;
|
|
}
|
|
else
|
|
{
|
|
num2 += num4 / num3;
|
|
num5 = num4 % num3;
|
|
if (num5 == 0)
|
|
{
|
|
num5 = num3;
|
|
}
|
|
else
|
|
{
|
|
num2++;
|
|
}
|
|
}
|
|
int num6 = 0;
|
|
while (this._decPointPos - num6 > num5 && num5 != 0)
|
|
{
|
|
this.AppendDigits(this._digitsLen - num6 - num5, this._digitsLen - num6);
|
|
num6 += num5;
|
|
this.Append(groupSeparator);
|
|
if (--num2 < groups.Length && num2 >= 0)
|
|
{
|
|
num3 = groups[num2];
|
|
}
|
|
num5 = num3;
|
|
}
|
|
this.AppendDigits(this._digitsLen - this._decPointPos, this._digitsLen - num6);
|
|
}
|
|
else
|
|
{
|
|
this.AppendDigits(this._digitsLen - this._decPointPos, this._digitsLen);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004041 RID: 16449 RVA: 0x000DA578 File Offset: 0x000D8778
|
|
private void AppendExponent(NumberFormatInfo nfi, int exponent, int minDigits)
|
|
{
|
|
if (this._specifierIsUpper || this._specifier == 'R')
|
|
{
|
|
this.Append('E');
|
|
}
|
|
else
|
|
{
|
|
this.Append('e');
|
|
}
|
|
if (exponent >= 0)
|
|
{
|
|
this.Append(nfi.PositiveSign);
|
|
}
|
|
else
|
|
{
|
|
this.Append(nfi.NegativeSign);
|
|
exponent = -exponent;
|
|
}
|
|
if (exponent == 0)
|
|
{
|
|
this.Append('0', minDigits);
|
|
}
|
|
else if (exponent < 10)
|
|
{
|
|
this.Append('0', minDigits - 1);
|
|
this.Append((char)(48 | exponent));
|
|
}
|
|
else
|
|
{
|
|
uint num = NumberFormatter.FastToDecHex(exponent);
|
|
if (exponent >= 100 || minDigits == 3)
|
|
{
|
|
this.Append((char)(48U | (num >> 8)));
|
|
}
|
|
this.Append((char)(48U | ((num >> 4) & 15U)));
|
|
this.Append((char)(48U | (num & 15U)));
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004042 RID: 16450 RVA: 0x000DA654 File Offset: 0x000D8854
|
|
private void AppendOneDigit(int start)
|
|
{
|
|
if (this._ind == this._cbuf.Length)
|
|
{
|
|
this.Resize(this._ind + 10);
|
|
}
|
|
start += this._offset;
|
|
uint num;
|
|
if (start < 0)
|
|
{
|
|
num = 0U;
|
|
}
|
|
else if (start < 8)
|
|
{
|
|
num = this._val1;
|
|
}
|
|
else if (start < 16)
|
|
{
|
|
num = this._val2;
|
|
}
|
|
else if (start < 24)
|
|
{
|
|
num = this._val3;
|
|
}
|
|
else if (start < 32)
|
|
{
|
|
num = this._val4;
|
|
}
|
|
else
|
|
{
|
|
num = 0U;
|
|
}
|
|
num >>= (start & 7) << 2;
|
|
this._cbuf[this._ind++] = (char)(48U | (num & 15U));
|
|
}
|
|
|
|
// Token: 0x06004043 RID: 16451 RVA: 0x000DA718 File Offset: 0x000D8918
|
|
private unsafe void FastAppendDigits(int val, bool force)
|
|
{
|
|
int ind = this._ind;
|
|
int num2;
|
|
if (force || val >= 100)
|
|
{
|
|
int num = val * 5243 >> 19;
|
|
num2 = NumberFormatter.DecHexDigits[num];
|
|
if (force || val >= 1000)
|
|
{
|
|
this._cbuf[ind++] = (char)(48 | (num2 >> 4));
|
|
}
|
|
this._cbuf[ind++] = (char)(48 | (num2 & 15));
|
|
num2 = NumberFormatter.DecHexDigits[val - num * 100];
|
|
}
|
|
else
|
|
{
|
|
num2 = NumberFormatter.DecHexDigits[val];
|
|
}
|
|
if (force || val >= 10)
|
|
{
|
|
this._cbuf[ind++] = (char)(48 | (num2 >> 4));
|
|
}
|
|
this._cbuf[ind++] = (char)(48 | (num2 & 15));
|
|
this._ind = ind;
|
|
}
|
|
|
|
// Token: 0x06004044 RID: 16452 RVA: 0x000DA7E4 File Offset: 0x000D89E4
|
|
private void AppendDigits(int start, int end)
|
|
{
|
|
if (start >= end)
|
|
{
|
|
return;
|
|
}
|
|
int num = this._ind + (end - start);
|
|
if (num > this._cbuf.Length)
|
|
{
|
|
this.Resize(num + 10);
|
|
}
|
|
this._ind = num;
|
|
end += this._offset;
|
|
start += this._offset;
|
|
int num2 = start + 8 - (start & 7);
|
|
for (;;)
|
|
{
|
|
uint num3;
|
|
if (num2 == 8)
|
|
{
|
|
num3 = this._val1;
|
|
}
|
|
else if (num2 == 16)
|
|
{
|
|
num3 = this._val2;
|
|
}
|
|
else if (num2 == 24)
|
|
{
|
|
num3 = this._val3;
|
|
}
|
|
else if (num2 == 32)
|
|
{
|
|
num3 = this._val4;
|
|
}
|
|
else
|
|
{
|
|
num3 = 0U;
|
|
}
|
|
num3 >>= (start & 7) << 2;
|
|
if (num2 > end)
|
|
{
|
|
num2 = end;
|
|
}
|
|
this._cbuf[--num] = (char)(48U | (num3 & 15U));
|
|
switch (num2 - start)
|
|
{
|
|
case 1:
|
|
goto IL_1C8;
|
|
case 2:
|
|
goto IL_1AB;
|
|
case 3:
|
|
goto IL_18E;
|
|
case 4:
|
|
goto IL_171;
|
|
case 5:
|
|
goto IL_154;
|
|
case 6:
|
|
goto IL_137;
|
|
case 7:
|
|
goto IL_11A;
|
|
case 8:
|
|
this._cbuf[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_11A;
|
|
}
|
|
IL_1D5:
|
|
start = num2;
|
|
num2 += 8;
|
|
continue;
|
|
IL_1C8:
|
|
if (num2 == end)
|
|
{
|
|
break;
|
|
}
|
|
goto IL_1D5;
|
|
IL_1AB:
|
|
this._cbuf[--num] = (char)(48U | ((num3 >> 4) & 15U));
|
|
goto IL_1C8;
|
|
IL_18E:
|
|
this._cbuf[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_1AB;
|
|
IL_171:
|
|
this._cbuf[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_18E;
|
|
IL_154:
|
|
this._cbuf[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_171;
|
|
IL_137:
|
|
this._cbuf[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_154;
|
|
IL_11A:
|
|
this._cbuf[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_137;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004045 RID: 16453 RVA: 0x000DA9D4 File Offset: 0x000D8BD4
|
|
private void AppendDigits(int start, int end, StringBuilder sb)
|
|
{
|
|
if (start >= end)
|
|
{
|
|
return;
|
|
}
|
|
int num = sb.Length + (end - start);
|
|
sb.Length = num;
|
|
end += this._offset;
|
|
start += this._offset;
|
|
int num2 = start + 8 - (start & 7);
|
|
for (;;)
|
|
{
|
|
uint num3;
|
|
if (num2 == 8)
|
|
{
|
|
num3 = this._val1;
|
|
}
|
|
else if (num2 == 16)
|
|
{
|
|
num3 = this._val2;
|
|
}
|
|
else if (num2 == 24)
|
|
{
|
|
num3 = this._val3;
|
|
}
|
|
else if (num2 == 32)
|
|
{
|
|
num3 = this._val4;
|
|
}
|
|
else
|
|
{
|
|
num3 = 0U;
|
|
}
|
|
num3 >>= (start & 7) << 2;
|
|
if (num2 > end)
|
|
{
|
|
num2 = end;
|
|
}
|
|
sb[--num] = (char)(48U | (num3 & 15U));
|
|
switch (num2 - start)
|
|
{
|
|
case 1:
|
|
goto IL_1A8;
|
|
case 2:
|
|
goto IL_18C;
|
|
case 3:
|
|
goto IL_170;
|
|
case 4:
|
|
goto IL_154;
|
|
case 5:
|
|
goto IL_138;
|
|
case 6:
|
|
goto IL_11C;
|
|
case 7:
|
|
goto IL_100;
|
|
case 8:
|
|
sb[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_100;
|
|
}
|
|
IL_1B5:
|
|
start = num2;
|
|
num2 += 8;
|
|
continue;
|
|
IL_1A8:
|
|
if (num2 == end)
|
|
{
|
|
break;
|
|
}
|
|
goto IL_1B5;
|
|
IL_18C:
|
|
sb[--num] = (char)(48U | ((num3 >> 4) & 15U));
|
|
goto IL_1A8;
|
|
IL_170:
|
|
sb[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_18C;
|
|
IL_154:
|
|
sb[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_170;
|
|
IL_138:
|
|
sb[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_154;
|
|
IL_11C:
|
|
sb[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_138;
|
|
IL_100:
|
|
sb[--num] = (char)(48U | ((num3 >>= 4) & 15U));
|
|
goto IL_11C;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06004046 RID: 16454 RVA: 0x000DABA4 File Offset: 0x000D8DA4
|
|
private void Multiply10(int count)
|
|
{
|
|
if (count <= 0 || this._digitsLen == 0)
|
|
{
|
|
return;
|
|
}
|
|
this._decPointPos += count;
|
|
}
|
|
|
|
// Token: 0x06004047 RID: 16455 RVA: 0x000DABC8 File Offset: 0x000D8DC8
|
|
private void Divide10(int count)
|
|
{
|
|
if (count <= 0 || this._digitsLen == 0)
|
|
{
|
|
return;
|
|
}
|
|
this._decPointPos -= count;
|
|
}
|
|
|
|
// Token: 0x06004048 RID: 16456 RVA: 0x000DABEC File Offset: 0x000D8DEC
|
|
private NumberFormatter GetClone()
|
|
{
|
|
return (NumberFormatter)base.MemberwiseClone();
|
|
}
|
|
|
|
// Token: 0x04001950 RID: 6480
|
|
private const int DefaultExpPrecision = 6;
|
|
|
|
// Token: 0x04001951 RID: 6481
|
|
private const int HundredMillion = 100000000;
|
|
|
|
// Token: 0x04001952 RID: 6482
|
|
private const long SeventeenDigitsThreshold = 10000000000000000L;
|
|
|
|
// Token: 0x04001953 RID: 6483
|
|
private const ulong ULongDivHundredMillion = 184467440737UL;
|
|
|
|
// Token: 0x04001954 RID: 6484
|
|
private const ulong ULongModHundredMillion = 9551616UL;
|
|
|
|
// Token: 0x04001955 RID: 6485
|
|
private const int DoubleBitsExponentShift = 52;
|
|
|
|
// Token: 0x04001956 RID: 6486
|
|
private const int DoubleBitsExponentMask = 2047;
|
|
|
|
// Token: 0x04001957 RID: 6487
|
|
private const long DoubleBitsMantissaMask = 4503599627370495L;
|
|
|
|
// Token: 0x04001958 RID: 6488
|
|
private const int DecimalBitsScaleMask = 2031616;
|
|
|
|
// Token: 0x04001959 RID: 6489
|
|
private const int SingleDefPrecision = 7;
|
|
|
|
// Token: 0x0400195A RID: 6490
|
|
private const int DoubleDefPrecision = 15;
|
|
|
|
// Token: 0x0400195B RID: 6491
|
|
private const int Int8DefPrecision = 3;
|
|
|
|
// Token: 0x0400195C RID: 6492
|
|
private const int UInt8DefPrecision = 3;
|
|
|
|
// Token: 0x0400195D RID: 6493
|
|
private const int Int16DefPrecision = 5;
|
|
|
|
// Token: 0x0400195E RID: 6494
|
|
private const int UInt16DefPrecision = 5;
|
|
|
|
// Token: 0x0400195F RID: 6495
|
|
private const int Int32DefPrecision = 10;
|
|
|
|
// Token: 0x04001960 RID: 6496
|
|
private const int UInt32DefPrecision = 10;
|
|
|
|
// Token: 0x04001961 RID: 6497
|
|
private const int Int64DefPrecision = 19;
|
|
|
|
// Token: 0x04001962 RID: 6498
|
|
private const int UInt64DefPrecision = 20;
|
|
|
|
// Token: 0x04001963 RID: 6499
|
|
private const int DecimalDefPrecision = 100;
|
|
|
|
// Token: 0x04001964 RID: 6500
|
|
private const int TenPowersListLength = 19;
|
|
|
|
// Token: 0x04001965 RID: 6501
|
|
private const double MinRoundtripVal = -1.79769313486231E+308;
|
|
|
|
// Token: 0x04001966 RID: 6502
|
|
private const double MaxRoundtripVal = 1.79769313486231E+308;
|
|
|
|
// Token: 0x04001967 RID: 6503
|
|
private unsafe static readonly ulong* MantissaBitsTable;
|
|
|
|
// Token: 0x04001968 RID: 6504
|
|
private unsafe static readonly int* TensExponentTable;
|
|
|
|
// Token: 0x04001969 RID: 6505
|
|
private unsafe static readonly char* DigitLowerTable;
|
|
|
|
// Token: 0x0400196A RID: 6506
|
|
private unsafe static readonly char* DigitUpperTable;
|
|
|
|
// Token: 0x0400196B RID: 6507
|
|
private unsafe static readonly long* TenPowersList;
|
|
|
|
// Token: 0x0400196C RID: 6508
|
|
private unsafe static readonly int* DecHexDigits;
|
|
|
|
// Token: 0x0400196D RID: 6509
|
|
private Thread _thread;
|
|
|
|
// Token: 0x0400196E RID: 6510
|
|
private NumberFormatInfo _nfi;
|
|
|
|
// Token: 0x0400196F RID: 6511
|
|
private bool _NaN;
|
|
|
|
// Token: 0x04001970 RID: 6512
|
|
private bool _infinity;
|
|
|
|
// Token: 0x04001971 RID: 6513
|
|
private bool _isCustomFormat;
|
|
|
|
// Token: 0x04001972 RID: 6514
|
|
private bool _specifierIsUpper;
|
|
|
|
// Token: 0x04001973 RID: 6515
|
|
private bool _positive;
|
|
|
|
// Token: 0x04001974 RID: 6516
|
|
private char _specifier;
|
|
|
|
// Token: 0x04001975 RID: 6517
|
|
private int _precision;
|
|
|
|
// Token: 0x04001976 RID: 6518
|
|
private int _defPrecision;
|
|
|
|
// Token: 0x04001977 RID: 6519
|
|
private int _digitsLen;
|
|
|
|
// Token: 0x04001978 RID: 6520
|
|
private int _offset;
|
|
|
|
// Token: 0x04001979 RID: 6521
|
|
private int _decPointPos;
|
|
|
|
// Token: 0x0400197A RID: 6522
|
|
private uint _val1;
|
|
|
|
// Token: 0x0400197B RID: 6523
|
|
private uint _val2;
|
|
|
|
// Token: 0x0400197C RID: 6524
|
|
private uint _val3;
|
|
|
|
// Token: 0x0400197D RID: 6525
|
|
private uint _val4;
|
|
|
|
// Token: 0x0400197E RID: 6526
|
|
private char[] _cbuf;
|
|
|
|
// Token: 0x0400197F RID: 6527
|
|
private int _ind;
|
|
|
|
// Token: 0x04001980 RID: 6528
|
|
[ThreadStatic]
|
|
private static NumberFormatter threadNumberFormatter;
|
|
|
|
// Token: 0x02000699 RID: 1689
|
|
private class CustomInfo
|
|
{
|
|
// Token: 0x0600404A RID: 16458 RVA: 0x000DAC14 File Offset: 0x000D8E14
|
|
public static void GetActiveSection(string format, ref bool positive, bool zero, ref int offset, ref int length)
|
|
{
|
|
int[] array = new int[3];
|
|
int num = 0;
|
|
int num2 = 0;
|
|
char c = '\0';
|
|
for (int i = 0; i < format.Length; i++)
|
|
{
|
|
char c2 = format[i];
|
|
if (c2 == c || (c == '\0' && (c2 == '"' || c2 == '\'')))
|
|
{
|
|
if (c == '\0')
|
|
{
|
|
c = c2;
|
|
}
|
|
else
|
|
{
|
|
c = '\0';
|
|
}
|
|
}
|
|
else if (c == '\0' && format[i] == ';' && (i == 0 || format[i - 1] != '\\'))
|
|
{
|
|
array[num++] = i - num2;
|
|
num2 = i + 1;
|
|
if (num == 3)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (num == 0)
|
|
{
|
|
offset = 0;
|
|
length = format.Length;
|
|
return;
|
|
}
|
|
if (num == 1)
|
|
{
|
|
if (positive || zero)
|
|
{
|
|
offset = 0;
|
|
length = array[0];
|
|
return;
|
|
}
|
|
if (array[0] + 1 < format.Length)
|
|
{
|
|
positive = true;
|
|
offset = array[0] + 1;
|
|
length = format.Length - offset;
|
|
return;
|
|
}
|
|
offset = 0;
|
|
length = array[0];
|
|
return;
|
|
}
|
|
else if (num == 2)
|
|
{
|
|
if (zero)
|
|
{
|
|
offset = array[0] + array[1] + 2;
|
|
length = format.Length - offset;
|
|
return;
|
|
}
|
|
if (positive)
|
|
{
|
|
offset = 0;
|
|
length = array[0];
|
|
return;
|
|
}
|
|
if (array[1] > 0)
|
|
{
|
|
positive = true;
|
|
offset = array[0] + 1;
|
|
length = array[1];
|
|
return;
|
|
}
|
|
offset = 0;
|
|
length = array[0];
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (num != 3)
|
|
{
|
|
throw new ArgumentException();
|
|
}
|
|
if (zero)
|
|
{
|
|
offset = array[0] + array[1] + 2;
|
|
length = array[2];
|
|
return;
|
|
}
|
|
if (positive)
|
|
{
|
|
offset = 0;
|
|
length = array[0];
|
|
return;
|
|
}
|
|
if (array[1] > 0)
|
|
{
|
|
positive = true;
|
|
offset = array[0] + 1;
|
|
length = array[1];
|
|
return;
|
|
}
|
|
offset = 0;
|
|
length = array[0];
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600404B RID: 16459 RVA: 0x000DADE8 File Offset: 0x000D8FE8
|
|
public static NumberFormatter.CustomInfo Parse(string format, int offset, int length, NumberFormatInfo nfi)
|
|
{
|
|
char c = '\0';
|
|
bool flag = true;
|
|
bool flag2 = false;
|
|
bool flag3 = false;
|
|
bool flag4 = true;
|
|
NumberFormatter.CustomInfo customInfo = new NumberFormatter.CustomInfo();
|
|
int num = 0;
|
|
int num2 = offset;
|
|
while (num2 - offset < length)
|
|
{
|
|
char c2 = format[num2];
|
|
if (c2 == c && c2 != '\0')
|
|
{
|
|
c = '\0';
|
|
}
|
|
else if (c == '\0')
|
|
{
|
|
if (flag3 && c2 != '\0' && c2 != '0' && c2 != '#')
|
|
{
|
|
flag3 = false;
|
|
flag = customInfo.DecimalPointPos < 0;
|
|
flag2 = !flag;
|
|
num2--;
|
|
}
|
|
else
|
|
{
|
|
char c3 = c2;
|
|
switch (c3)
|
|
{
|
|
case '"':
|
|
case '\'':
|
|
if (c2 == '"' || c2 == '\'')
|
|
{
|
|
c = c2;
|
|
}
|
|
goto IL_311;
|
|
case '#':
|
|
if (flag4 && flag)
|
|
{
|
|
customInfo.IntegerHeadSharpDigits++;
|
|
}
|
|
else if (flag2)
|
|
{
|
|
customInfo.DecimalTailSharpDigits++;
|
|
}
|
|
else if (flag3)
|
|
{
|
|
customInfo.ExponentTailSharpDigits++;
|
|
}
|
|
break;
|
|
default:
|
|
switch (c3)
|
|
{
|
|
case ',':
|
|
if (flag && customInfo.IntegerDigits > 0)
|
|
{
|
|
num++;
|
|
}
|
|
goto IL_311;
|
|
default:
|
|
if (c3 != 'E')
|
|
{
|
|
if (c3 == '\\')
|
|
{
|
|
num2++;
|
|
goto IL_311;
|
|
}
|
|
if (c3 != 'e')
|
|
{
|
|
if (c3 != '‰')
|
|
{
|
|
goto IL_311;
|
|
}
|
|
customInfo.Permilles++;
|
|
goto IL_311;
|
|
}
|
|
}
|
|
if (customInfo.UseExponent)
|
|
{
|
|
goto IL_311;
|
|
}
|
|
customInfo.UseExponent = true;
|
|
flag = false;
|
|
flag2 = false;
|
|
flag3 = true;
|
|
if (num2 + 1 - offset < length)
|
|
{
|
|
char c4 = format[num2 + 1];
|
|
if (c4 == '+')
|
|
{
|
|
customInfo.ExponentNegativeSignOnly = false;
|
|
}
|
|
if (c4 == '+' || c4 == '-')
|
|
{
|
|
num2++;
|
|
}
|
|
else if (c4 != '0' && c4 != '#')
|
|
{
|
|
customInfo.UseExponent = false;
|
|
if (customInfo.DecimalPointPos < 0)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
goto IL_311;
|
|
case '.':
|
|
flag = false;
|
|
flag2 = true;
|
|
flag3 = false;
|
|
if (customInfo.DecimalPointPos == -1)
|
|
{
|
|
customInfo.DecimalPointPos = num2;
|
|
}
|
|
goto IL_311;
|
|
case '0':
|
|
break;
|
|
}
|
|
break;
|
|
case '%':
|
|
customInfo.Percents++;
|
|
goto IL_311;
|
|
}
|
|
if (c2 != '#')
|
|
{
|
|
flag4 = false;
|
|
if (flag2)
|
|
{
|
|
customInfo.DecimalTailSharpDigits = 0;
|
|
}
|
|
else if (flag3)
|
|
{
|
|
customInfo.ExponentTailSharpDigits = 0;
|
|
}
|
|
}
|
|
if (customInfo.IntegerHeadPos == -1)
|
|
{
|
|
customInfo.IntegerHeadPos = num2;
|
|
}
|
|
if (flag)
|
|
{
|
|
customInfo.IntegerDigits++;
|
|
if (num > 0)
|
|
{
|
|
customInfo.UseGroup = true;
|
|
}
|
|
num = 0;
|
|
}
|
|
else if (flag2)
|
|
{
|
|
customInfo.DecimalDigits++;
|
|
}
|
|
else if (flag3)
|
|
{
|
|
customInfo.ExponentDigits++;
|
|
}
|
|
}
|
|
}
|
|
IL_311:
|
|
num2++;
|
|
}
|
|
if (customInfo.ExponentDigits == 0)
|
|
{
|
|
customInfo.UseExponent = false;
|
|
}
|
|
else
|
|
{
|
|
customInfo.IntegerHeadSharpDigits = 0;
|
|
}
|
|
if (customInfo.DecimalDigits == 0)
|
|
{
|
|
customInfo.DecimalPointPos = -1;
|
|
}
|
|
customInfo.DividePlaces += num * 3;
|
|
return customInfo;
|
|
}
|
|
|
|
// Token: 0x0600404C RID: 16460 RVA: 0x000DB160 File Offset: 0x000D9360
|
|
public string Format(string format, int offset, int length, NumberFormatInfo nfi, bool positive, StringBuilder sb_int, StringBuilder sb_dec, StringBuilder sb_exp)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
char c = '\0';
|
|
bool flag = true;
|
|
bool flag2 = false;
|
|
int num = 0;
|
|
int i = 0;
|
|
int num2 = 0;
|
|
int[] rawNumberGroupSizes = nfi.RawNumberGroupSizes;
|
|
string numberGroupSeparator = nfi.NumberGroupSeparator;
|
|
int num3 = 0;
|
|
int num4 = 0;
|
|
int num5 = 0;
|
|
int num6 = 0;
|
|
int num7 = 0;
|
|
if (this.UseGroup && rawNumberGroupSizes.Length > 0)
|
|
{
|
|
num3 = sb_int.Length;
|
|
for (int j = 0; j < rawNumberGroupSizes.Length; j++)
|
|
{
|
|
num4 += rawNumberGroupSizes[j];
|
|
if (num4 <= num3)
|
|
{
|
|
num5 = j;
|
|
}
|
|
}
|
|
num7 = rawNumberGroupSizes[num5];
|
|
int num8 = ((num3 <= num4) ? 0 : (num3 - num4));
|
|
if (num7 == 0)
|
|
{
|
|
while (num5 >= 0 && rawNumberGroupSizes[num5] == 0)
|
|
{
|
|
num5--;
|
|
}
|
|
num7 = ((num8 <= 0) ? rawNumberGroupSizes[num5] : num8);
|
|
}
|
|
if (num8 == 0)
|
|
{
|
|
num6 = num7;
|
|
}
|
|
else
|
|
{
|
|
num5 += num8 / num7;
|
|
num6 = num8 % num7;
|
|
if (num6 == 0)
|
|
{
|
|
num6 = num7;
|
|
}
|
|
else
|
|
{
|
|
num5++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.UseGroup = false;
|
|
}
|
|
int num9 = offset;
|
|
while (num9 - offset < length)
|
|
{
|
|
char c2 = format[num9];
|
|
if (c2 == c && c2 != '\0')
|
|
{
|
|
c = '\0';
|
|
}
|
|
else if (c != '\0')
|
|
{
|
|
stringBuilder.Append(c2);
|
|
}
|
|
else
|
|
{
|
|
char c3 = c2;
|
|
switch (c3)
|
|
{
|
|
case '"':
|
|
case '\'':
|
|
if (c2 == '"' || c2 == '\'')
|
|
{
|
|
c = c2;
|
|
}
|
|
goto IL_474;
|
|
case '#':
|
|
break;
|
|
default:
|
|
switch (c3)
|
|
{
|
|
case ',':
|
|
goto IL_474;
|
|
default:
|
|
{
|
|
if (c3 != 'E')
|
|
{
|
|
if (c3 == '\\')
|
|
{
|
|
num9++;
|
|
if (num9 - offset < length)
|
|
{
|
|
stringBuilder.Append(format[num9]);
|
|
}
|
|
goto IL_474;
|
|
}
|
|
if (c3 != 'e')
|
|
{
|
|
if (c3 != '‰')
|
|
{
|
|
stringBuilder.Append(c2);
|
|
goto IL_474;
|
|
}
|
|
stringBuilder.Append(nfi.PerMilleSymbol);
|
|
goto IL_474;
|
|
}
|
|
}
|
|
if (sb_exp == null || !this.UseExponent)
|
|
{
|
|
stringBuilder.Append(c2);
|
|
goto IL_474;
|
|
}
|
|
bool flag3 = true;
|
|
bool flag4 = false;
|
|
int num10 = num9 + 1;
|
|
while (num10 - offset < length)
|
|
{
|
|
if (format[num10] == '0')
|
|
{
|
|
flag4 = true;
|
|
}
|
|
else if (num10 != num9 + 1 || (format[num10] != '+' && format[num10] != '-'))
|
|
{
|
|
if (!flag4)
|
|
{
|
|
flag3 = false;
|
|
}
|
|
break;
|
|
}
|
|
num10++;
|
|
}
|
|
if (flag3)
|
|
{
|
|
num9 = num10 - 1;
|
|
flag = this.DecimalPointPos < 0;
|
|
flag2 = !flag;
|
|
stringBuilder.Append(c2);
|
|
stringBuilder.Append(sb_exp);
|
|
sb_exp = null;
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(c2);
|
|
}
|
|
goto IL_474;
|
|
}
|
|
case '.':
|
|
if (this.DecimalPointPos == num9)
|
|
{
|
|
if (this.DecimalDigits > 0)
|
|
{
|
|
while (i < sb_int.Length)
|
|
{
|
|
stringBuilder.Append(sb_int[i++]);
|
|
}
|
|
}
|
|
if (sb_dec.Length > 0)
|
|
{
|
|
stringBuilder.Append(nfi.NumberDecimalSeparator);
|
|
}
|
|
}
|
|
flag = false;
|
|
flag2 = true;
|
|
goto IL_474;
|
|
case '0':
|
|
break;
|
|
}
|
|
break;
|
|
case '%':
|
|
stringBuilder.Append(nfi.PercentSymbol);
|
|
goto IL_474;
|
|
}
|
|
if (flag)
|
|
{
|
|
num++;
|
|
if (this.IntegerDigits - num < sb_int.Length + i || c2 == '0')
|
|
{
|
|
while (this.IntegerDigits - num + i < sb_int.Length)
|
|
{
|
|
stringBuilder.Append(sb_int[i++]);
|
|
if (this.UseGroup && --num3 > 0 && --num6 == 0)
|
|
{
|
|
stringBuilder.Append(numberGroupSeparator);
|
|
if (--num5 < rawNumberGroupSizes.Length && num5 >= 0)
|
|
{
|
|
num7 = rawNumberGroupSizes[num5];
|
|
}
|
|
num6 = num7;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (flag2)
|
|
{
|
|
if (num2 < sb_dec.Length)
|
|
{
|
|
stringBuilder.Append(sb_dec[num2++]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(c2);
|
|
}
|
|
}
|
|
IL_474:
|
|
num9++;
|
|
}
|
|
if (!positive)
|
|
{
|
|
stringBuilder.Insert(0, nfi.NegativeSign);
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x04001981 RID: 6529
|
|
public bool UseGroup;
|
|
|
|
// Token: 0x04001982 RID: 6530
|
|
public int DecimalDigits;
|
|
|
|
// Token: 0x04001983 RID: 6531
|
|
public int DecimalPointPos = -1;
|
|
|
|
// Token: 0x04001984 RID: 6532
|
|
public int DecimalTailSharpDigits;
|
|
|
|
// Token: 0x04001985 RID: 6533
|
|
public int IntegerDigits;
|
|
|
|
// Token: 0x04001986 RID: 6534
|
|
public int IntegerHeadSharpDigits;
|
|
|
|
// Token: 0x04001987 RID: 6535
|
|
public int IntegerHeadPos;
|
|
|
|
// Token: 0x04001988 RID: 6536
|
|
public bool UseExponent;
|
|
|
|
// Token: 0x04001989 RID: 6537
|
|
public int ExponentDigits;
|
|
|
|
// Token: 0x0400198A RID: 6538
|
|
public int ExponentTailSharpDigits;
|
|
|
|
// Token: 0x0400198B RID: 6539
|
|
public bool ExponentNegativeSignOnly = true;
|
|
|
|
// Token: 0x0400198C RID: 6540
|
|
public int DividePlaces;
|
|
|
|
// Token: 0x0400198D RID: 6541
|
|
public int Percents;
|
|
|
|
// Token: 0x0400198E RID: 6542
|
|
public int Permilles;
|
|
}
|
|
}
|
|
}
|