static int CheckForOverflow(ulong number, NumberKind numberKind)
{
switch (numberKind)
{
case NumberKind.Int8:
return(number > (ulong)sbyte.MaxValue ? 1 : 0);
case NumberKind.Int16:
return(number > (ulong)short.MaxValue ? 1 : 0);
case NumberKind.Int32:
return(number > (ulong)int.MaxValue ? 1 : 0);
case NumberKind.Int64:
return(number > (ulong)long.MaxValue ? 1 : 0);
case NumberKind.UInt8:
return(number > (ulong)byte.MaxValue ? 1 : 0);
case NumberKind.UInt16:
return(number > (ulong)ushort.MaxValue ? 1 : 0);
case NumberKind.UInt32:
return(number > (ulong)uint.MaxValue ? 1 : 0);
case NumberKind.UInt64:
return(0);
default:
return(0);
}
}
public static bool IsNumberOfType(int number, NumberKind kind)
{
if (number == 0 && kind != NumberKind.Zero)
return false;
switch (kind)
{
case NumberKind.Zero:
return number == 0;
case NumberKind.Red:
return _RedNumbers.Contains(number);
case NumberKind.Black:
return _BlackNumbers.Contains(number);
case NumberKind.Odd:
return number % 2 == 1;
case NumberKind.Even:
return number % 2 == 0;
case NumberKind.To18:
return number <= 18;
case NumberKind.From19:
return number >= 19;
}
return false;
}
static int CheckForOverflow(double number, NumberKind numberKind)
{
switch (numberKind)
{
case NumberKind.Int8:
return(number > sbyte.MaxValue ? 1 : (number < sbyte.MinValue ? -1 : 0));
case NumberKind.Int16:
return(number > short.MaxValue ? 1 : (number < short.MinValue ? -1 : 0));
case NumberKind.Int32:
return(number > int.MaxValue ? 1 : (number < int.MinValue ? -1 : 0));
case NumberKind.Int64:
return(number > long.MaxValue ? 1 : (number < long.MinValue ? -1 : 0));
case NumberKind.UInt8:
return(number > byte.MaxValue ? 1 : (number < 0 ? -1 : 0));
case NumberKind.UInt16:
return(number > ushort.MaxValue ? 1 : (number < 0 ? -1 : 0));
case NumberKind.UInt32:
return(number > uint.MaxValue ? 1 : (number < 0 ? -1 : 0));
case NumberKind.UInt64:
return(number > ulong.MaxValue ? 1 : (number < 0 ? -1 : 0));
default:
return(0);
}
}
public Number(ulong number, NumberKind numberKind)
{
this.Kind = numberKind;
if (numberKind.IsInteger())
{
var overflows = CheckForOverflow(number, numberKind);
if (overflows == 1)
{
this.State = NumberState.Overflow;
}
else if (overflows == -1)
{
this.State = NumberState.Underflow;
}
if (!HasErrors)
{
this.Value = LLVM.ConstInt(GetLLVMType(), number, new LLVMBool(0));
}
}
else
{
this.APFloat = LLVMExt.APFloatZero(GetAPFloatSemantics(this.Kind));
this.State |= (NumberState)LLVMExt.APFloatFromString(this.APFloat, number.ToString(CultureInfo.InvariantCulture), RoundingMode);
}
}
public Number(string number, NumberKind numberKind)
{
if (number == null)
{
throw new ArgumentNullException(nameof(number));
}
this.Kind = numberKind;
if (numberKind.IsInteger())
{
this.State = CheckIntegerString(number, numberKind);
if (!this.HasErrors)
{
this.Value = LLVM.ConstIntOfString(LLVM.Int128Type(), number, 10);
}
}
else
{
this.State = CheckFloatString(number);
if (!this.HasErrors)
{
this.APFloat = LLVMExt.APFloatZero(GetAPFloatSemantics(this.Kind));
this.State |= (NumberState)LLVMExt.APFloatFromString(this.APFloat, number, RoundingMode);
}
}
}
public async Task <NumberKind> AddNumberKind(NumberKind c)
{
var result = await peopleDbContext.NumberKinds.AddAsync(c);
await peopleDbContext.SaveChangesAsync();
return(result.Entity);
}
internal static ExpressionValueKind Convert(NumberKind kind)
{
switch (kind)
{
case NumberKind.Integer: return ExpressionValueKind.Integer;
case NumberKind.Long: return ExpressionValueKind.Long;
case NumberKind.Single: return ExpressionValueKind.Single;
case NumberKind.Double: return ExpressionValueKind.Double;
default: throw Contract.CreateInvalidEnumValueException(kind);
}
}
static NumberState CheckIntegerString(string number, NumberKind numberKind)
{
if (!IntegerRegex.IsMatch(number))
{
return(NumberState.Invalid);
}
var isNegative = number.StartsWith("-", StringComparison.InvariantCultureIgnoreCase);
var overflows = CheckForOverflow(number, numberKind);
return(overflows ? (isNegative ? NumberState.Underflow : NumberState.Overflow) : NumberState.Ok);
}
NumberState CheckForOpOverflow(NumberKind opKind, LLVMValueRef result)
{
if (opKind.IsSigned())
{
var lessThan = LLVM.ConstICmp(LLVMIntPredicate.LLVMIntSLT, result, MinLongLLVMValue).ConstIntGetZExtValue() == 1;
if (lessThan)
{
return(NumberState.Underflow);
}
var greatherThan = LLVM.ConstICmp(LLVMIntPredicate.LLVMIntSGT, result, MaxLongLLVMValue).ConstIntGetZExtValue() == 1;
if (greatherThan)
{
return(NumberState.Overflow);
}
var overflows = CheckForOverflow(result.ConstIntGetSExtValue(), opKind);
if (overflows == 1)
{
return(NumberState.Overflow);
}
else if (overflows == -1)
{
return(NumberState.Underflow);
}
else
{
return(NumberState.Ok);
}
}
else
{
var greatherThan = LLVM.ConstICmp(LLVMIntPredicate.LLVMIntUGT, result, MaxULongLLVMValue).ConstIntGetZExtValue() == 1;
if (greatherThan)
{
return(NumberState.Overflow);
}
var overflows = CheckForOverflow(result.ConstIntGetZExtValue(), opKind);
if (overflows == 1)
{
return(NumberState.Overflow);
}
else if (overflows == -1)
{
return(NumberState.Underflow);
}
else
{
return(NumberState.Ok);
}
}
}
public NumberSemantics(
NumberKind DefaultKind = NumberKind.Int32,
FloatSemantics LongDoubleSemantics = FloatSemantics.X87DoubleExtended,
FloatSemantics QuadSemantics = FloatSemantics.IEEEQuad)
{
if (!DefaultKind.IsInteger())
{
throw new ArgumentException("DefaultKind must be an integer", nameof(DefaultKind));
}
this.DefaultKind = DefaultKind;
this.LongDoubleSemantics = LongDoubleSemantics;
this.QuadSemantics = QuadSemantics;
}
private NumberKind ScanOptionalIntegerSuffix()
{
NumberKind unsuffixedInteger = NumberKind.UnsuffixedInteger;
char ch2 = this.CurrentChar();
if (ch2 <= 'U')
{
switch (ch2)
{
case 'L':
goto Label_0028;
case 'U':
goto Label_0048;
}
return(unsuffixedInteger);
}
switch (ch2)
{
case 'l':
break;
case 'u':
goto Label_0048;
default:
return(unsuffixedInteger);
}
Label_0028:
switch (this.NextChar())
{
case 'u':
case 'U':
unsuffixedInteger = NumberKind.Unsigned | NumberKind.Long;
this.NextChar();
return(unsuffixedInteger);
default:
return(NumberKind.Long);
}
Label_0048:
switch (this.NextChar())
{
case 'l':
case 'L':
unsuffixedInteger = NumberKind.Unsigned | NumberKind.Long;
this.NextChar();
return(unsuffixedInteger);
}
return(NumberKind.Unsigned);
}
public async Task <NumberKind> UpdateNumberKind(NumberKind c)
{
var result = await peopleDbContext.NumberKinds
.FirstOrDefaultAsync(e => e.NumberKindId == c.NumberKindId);
if (result != null)
{
result.Label = c.Label;
await peopleDbContext.SaveChangesAsync();
return(result);
}
return(null);
}
private NumberKind ScanExponent(StringBuilder buffer)
{
char ch = CurrentChar();
if (ch == '-' || ch == '+')
{
buffer.Append(ch);
ch = NextChar();
}
if (!char.IsDigit(ch))
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidExponentDigit, ch);
throw new RuleSyntaxException(ErrorNumbers.Error_InvalidExponentDigit, message, currentPosition);
}
do
{
buffer.Append(ch);
ch = NextChar();
} while (char.IsDigit(ch));
NumberKind numberKind = NumberKind.Double;
switch (ch)
{
case 'd':
case 'D':
numberKind = NumberKind.Double;
NextChar();
break;
case 'f':
case 'F':
numberKind = NumberKind.Float;
NextChar();
break;
case 'm':
case 'M':
numberKind = NumberKind.Decimal;
NextChar();
break;
}
return(numberKind);
}
static bool CheckForOverflow(string number, NumberKind numberKind)
{
try {
switch (numberKind)
{
case NumberKind.Int8:
sbyte.Parse(number, CultureInfo.InvariantCulture);
break;
case NumberKind.Int16:
short.Parse(number, CultureInfo.InvariantCulture);
break;
case NumberKind.Int32:
int.Parse(number, CultureInfo.InvariantCulture);
break;
case NumberKind.Int64:
long.Parse(number, CultureInfo.InvariantCulture);
break;
case NumberKind.UInt8:
byte.Parse(number, CultureInfo.InvariantCulture);
break;
case NumberKind.UInt16:
ushort.Parse(number, CultureInfo.InvariantCulture);
break;
case NumberKind.UInt32:
uint.Parse(number, CultureInfo.InvariantCulture);
break;
case NumberKind.UInt64:
ulong.Parse(number, CultureInfo.InvariantCulture);
break;
default:
throw new NotSupportedException();
}
return(false);
}
catch {
return(true);
}
}
public static bool IsInteger(this NumberKind kind)
{
switch (kind)
{
case NumberKind.Int8:
case NumberKind.Int16:
case NumberKind.Int32:
case NumberKind.Int64:
case NumberKind.UInt8:
case NumberKind.UInt16:
case NumberKind.UInt32:
case NumberKind.UInt64:
return(true);
default:
return(false);
}
}
public static bool IsSigned(this NumberKind kind)
{
switch (kind)
{
case NumberKind.Int8:
case NumberKind.Int16:
case NumberKind.Int32:
case NumberKind.Int64:
case NumberKind.Float:
case NumberKind.Double:
case NumberKind.Real:
case NumberKind.Quad:
return(true);
default:
return(false);
}
}
private NumberKind ScanFraction(StringBuilder buffer)
{
char ch = CurrentChar();
while (char.IsDigit(ch))
{
buffer.Append(ch);
ch = NextChar();
}
NumberKind numberKind = NumberKind.Double;
switch (ch)
{
case 'e':
case 'E':
buffer.Append('E');
NextChar();
numberKind = ScanExponent(buffer);
break;
case 'd':
case 'D':
numberKind = NumberKind.Double;
NextChar();
break;
case 'f':
case 'F':
numberKind = NumberKind.Float;
NextChar();
break;
case 'm':
case 'M':
numberKind = NumberKind.Decimal;
NextChar();
break;
}
return(numberKind);
}
private NumberKind ScanOptionalIntegerSuffix()
{
NumberKind numberKind = NumberKind.UnsuffixedInteger;
char ch = CurrentChar();
switch (ch)
{
case 'l':
case 'L':
ch = NextChar(); // eat the 'L'
if (ch == 'u' || ch == 'U')
{
// "LU" is a ulong.
numberKind = NumberKind.Long | NumberKind.Unsigned;
NextChar(); // eat the 'U'
}
else
{
// "L" is a long
numberKind = NumberKind.Long;
}
break;
case 'u':
case 'U':
ch = NextChar(); // Eat the 'U'
if (ch == 'l' || ch == 'L')
{
// "UL" is a ulong.
numberKind = NumberKind.Long | NumberKind.Unsigned;
NextChar(); // eat the 'L'
}
else
{
numberKind = NumberKind.Unsigned;
}
break;
}
return(numberKind);
}
public static NumberKind Signed(this NumberKind kind)
{
switch (kind)
{
case NumberKind.UInt8:
return(NumberKind.Int8);
case NumberKind.UInt16:
return(NumberKind.Int16);
case NumberKind.UInt32:
return(NumberKind.Int32);
case NumberKind.UInt64:
return(NumberKind.Int64);
default:
return(kind);
}
}
static APFloatSemantics GetAPFloatSemantics(NumberKind kind)
{
switch (kind)
{
case NumberKind.Float:
return(APFloatSemantics.IEEEsingle);
case NumberKind.Double:
return(APFloatSemantics.IEEEdouble);
case NumberKind.Real:
case NumberKind.Quad:
switch (kind == NumberKind.Real ? Semantics.LongDoubleSemantics : Semantics.QuadSemantics)
{
case FloatSemantics.IEEEHalf:
return(APFloatSemantics.IEEEhalf);
case FloatSemantics.IEEESingle:
return(APFloatSemantics.IEEEsingle);
case FloatSemantics.IEEEDouble:
return(APFloatSemantics.IEEEdouble);
case FloatSemantics.IEEEQuad:
return(APFloatSemantics.IEEEquad);
case FloatSemantics.PPCDoubleDouble:
return(APFloatSemantics.PPCDoubleDouble);
case FloatSemantics.X87DoubleExtended:
return(APFloatSemantics.X87DoubleExtended);
default:
throw new NotSupportedException();
}
default:
throw new NotSupportedException();
}
}
public static NumberKind Unsigned(this NumberKind kind)
{
switch (kind)
{
case NumberKind.Int8:
case NumberKind.UInt8:
return(NumberKind.UInt8);
case NumberKind.Int16:
case NumberKind.UInt16:
return(NumberKind.UInt16);
case NumberKind.Int32:
case NumberKind.UInt32:
return(NumberKind.UInt32);
case NumberKind.Int64:
case NumberKind.UInt64:
return(NumberKind.UInt64);
default:
throw new NotSupportedException("doesn't have an unsigned counterpart");
}
}
public Number(double number, NumberKind numberKind)
{
this.Kind = numberKind;
if (numberKind.IsInteger())
{
var overflows = CheckForOverflow(number, numberKind);
if (overflows == 1)
{
this.State = NumberState.Overflow;
}
else if (overflows == -1)
{
this.State = NumberState.Underflow;
}
if (!HasErrors)
{
this.Value = LLVM.ConstReal(LLVM.DoubleType(), number);
if (numberKind.IsSigned())
{
this.Value = LLVM.ConstFPToSI(this.Value, GetLLVMType());
}
else
{
this.Value = LLVM.ConstFPToUI(this.Value, GetLLVMType());
}
}
}
else
{
int state;
this.APFloat = LLVMExt.APFloatFromDouble(number, GetAPFloatSemantics(this.Kind), out state);
this.State |= (NumberState)state;
}
}
static NumberKind GetBestFloatKind(NumberKind k1, NumberKind k2)
{
var kSize = k1.BitSize(Semantics);
if (kSize == 64)
{
return(NumberKind.Double);
}
else if (kSize == 32)
{
return(NumberKind.Float);
}
else
{
if (k1 == NumberKind.Real || k2 == NumberKind.Real)
{
return(NumberKind.Real);
}
else
{
return(NumberKind.Quad);
}
}
}
public NumberType(NumberKind numberKind, int bitSize)
{
NumberKind = numberKind;
BitSize = bitSize;
}
// Output Setters
private void outputSetBin(object sender, RoutedEventArgs e)
{
outputKind = NumberKind.Binary;
}
private TokenID ScanHexNumber()
{
char ch = CurrentChar();
int hValue = HexValue(ch);
if (hValue < 0)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidHexDigit, ch);
throw new RuleSyntaxException(ErrorNumbers.Error_InvalidHexDigit, message, currentPosition);
}
int length = 1;
ulong value = (ulong)hValue;
ch = NextChar();
hValue = HexValue(ch);
while (hValue >= 0)
{
++length;
value = (value * 16) + (ulong)hValue;
ch = NextChar();
hValue = HexValue(ch);
}
if (length > sizeof(ulong) * 2)
{
// We had overflow.
string message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidIntegerConstant, string.Empty);
throw new RuleSyntaxException(ErrorNumbers.Error_InvalidIntegerLiteral, message, tokenStartPosition);
}
TokenID token = TokenID.IntegerLiteral;
NumberKind numberKind = ScanOptionalIntegerSuffix();
switch (numberKind)
{
case NumberKind.UnsuffixedInteger:
// It's an "int" if it fits, else it's a "long" if it fits, else it's a "ulong".
if (value > long.MaxValue) // too big for long, keep it ulong
{
tokenValue = value;
}
else if (value <= int.MaxValue) // fits into an int
{
tokenValue = (int)value;
}
else
{
tokenValue = (long)value; // it's a long
}
break;
case NumberKind.Long:
tokenValue = (long)value;
break;
case NumberKind.Unsigned:
// It's a "uint" if it fits, else its a "ulong"
if (value <= uint.MaxValue)
{
tokenValue = (uint)value;
}
else
{
tokenValue = value;
}
break;
case NumberKind.Unsigned | NumberKind.Long:
tokenValue = value;
break;
}
return(token);
}
private void outputSetHex(object sender, RoutedEventArgs e)
{
outputKind = NumberKind.Hexa;
}
private void outputSetInt(object sender, RoutedEventArgs e)
{
outputKind = NumberKind.Int32;
}
private TokenID ScanDecimal()
{
NumberKind numberKind = NumberKind.UnsuffixedInteger; // Start by assuming it's an "int" constant.
StringBuilder buffer = new StringBuilder();
char ch = CurrentChar();
while (char.IsDigit(ch))
{
buffer.Append(ch);
ch = NextChar();
}
switch (ch)
{
case '.':
numberKind = NumberKind.Double; // It's a double or float.
buffer.Append('.');
NextChar(); // eat the '.'
numberKind = ScanFraction(buffer);
break;
case 'e':
case 'E':
buffer.Append('e');
NextChar(); // eat the 'e'
numberKind = ScanExponent(buffer);
break;
case 'f':
case 'F':
numberKind = NumberKind.Float;
NextChar(); // eat the 'f'
break;
case 'd':
case 'D':
numberKind = NumberKind.Double;
NextChar(); // eat the 'd'
break;
case 'm':
case 'M':
numberKind = NumberKind.Decimal;
NextChar(); // eat the 'm'
break;
default:
numberKind = ScanOptionalIntegerSuffix();
break;
}
string message;
TokenID token;
string numberString = buffer.ToString();
if (numberKind == NumberKind.Float)
{
token = TokenID.FloatLiteral;
try
{
tokenValue = float.Parse(numberString, NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture);
}
catch (Exception exception)
{
message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidFloatingPointConstant, exception.Message);
throw new RuleSyntaxException(ErrorNumbers.Error_InvalidRealLiteral, message, tokenStartPosition);
}
}
else if (numberKind == NumberKind.Double)
{
token = TokenID.FloatLiteral;
try
{
tokenValue = double.Parse(numberString, NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture);
}
catch (Exception exception)
{
message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidFloatingPointConstant, exception.Message);
throw new RuleSyntaxException(ErrorNumbers.Error_InvalidRealLiteral, message, tokenStartPosition);
}
}
else if (numberKind == NumberKind.Decimal)
{
token = TokenID.DecimalLiteral;
try
{
tokenValue = decimal.Parse(numberString, NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture);
}
catch (Exception exception)
{
message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidDecimalConstant, exception.Message);
throw new RuleSyntaxException(ErrorNumbers.Error_InvalidRealLiteral, message, tokenStartPosition);
}
}
else
{
token = TokenID.IntegerLiteral;
ulong value = 0;
try
{
value = ulong.Parse(numberString, CultureInfo.InvariantCulture);
}
catch (Exception exception)
{
message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidIntegerConstant, exception.Message);
throw new RuleSyntaxException(ErrorNumbers.Error_InvalidIntegerLiteral, message, tokenStartPosition);
}
switch (numberKind)
{
case NumberKind.UnsuffixedInteger:
// It's an "int" if it fits, else it's a "long" if it fits, else it's a "ulong".
if (value > long.MaxValue) // too big for long, keep it ulong
{
tokenValue = value;
}
else if (value <= int.MaxValue) // fits into an int
{
tokenValue = (int)value;
}
else
{
tokenValue = (long)value; // it's a long
}
break;
case NumberKind.Long:
tokenValue = (long)value;
break;
case NumberKind.Unsigned:
// It's a "uint" if it fits, else its a "ulong"
if (value <= uint.MaxValue)
{
tokenValue = (uint)value;
}
else
{
tokenValue = value;
}
break;
case NumberKind.Unsigned | NumberKind.Long:
tokenValue = value;
break;
}
}
return(token);
}
public void AddNumberKindBalancePoint(NumberKind numKind, int advantage)
{
int newPointY = (MainWindow.NumberBalancesCanvasHeight / 2) - advantage;
if (numKind == NumberKind.Red)
{
UpdateNumberBalances(RedBlackBalancesLine, newPointY);
}
else if (numKind == NumberKind.Even)
{
UpdateNumberBalances(EvenOddBalancesLine, newPointY);
}
else if (numKind == NumberKind.To18)
{
UpdateNumberBalances(To18From19BalancesLine, newPointY);
}
}
private NumberKind ScanFraction(StringBuilder buffer)
{
char c = this.CurrentChar();
while (char.IsDigit(c))
{
buffer.Append(c);
c = this.NextChar();
}
NumberKind kind = NumberKind.Double;
char ch2 = c;
if (ch2 <= 'M')
{
switch (ch2)
{
case 'D':
goto Label_007B;
case 'E':
goto Label_0061;
case 'F':
goto Label_0086;
case 'M':
goto Label_0092;
}
return(kind);
}
switch (ch2)
{
case 'd':
goto Label_007B;
case 'e':
break;
case 'f':
goto Label_0086;
case 'm':
goto Label_0092;
default:
return(kind);
}
Label_0061:
buffer.Append('E');
this.NextChar();
return(this.ScanExponent(buffer));
Label_007B:
kind = NumberKind.Double;
this.NextChar();
return(kind);
Label_0086:
kind = NumberKind.Float;
this.NextChar();
return(kind);
Label_0092:
kind = NumberKind.Decimal;
this.NextChar();
return(kind);
}
private NumberKind ScanExponent(StringBuilder buffer)
{
char ch = this.CurrentChar();
switch (ch)
{
case '-':
case '+':
buffer.Append(ch);
ch = this.NextChar();
break;
}
if (!char.IsDigit(ch))
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidExponentDigit, new object[] { ch });
throw new RuleSyntaxException(0x17e, message, this.currentPosition);
}
do
{
buffer.Append(ch);
ch = this.NextChar();
}while (char.IsDigit(ch));
NumberKind kind = NumberKind.Double;
char ch2 = ch;
if (ch2 <= 'M')
{
switch (ch2)
{
case 'D':
goto Label_00B9;
case 'E':
return(kind);
case 'F':
goto Label_00C4;
case 'M':
goto Label_00D0;
}
return(kind);
}
switch (ch2)
{
case 'd':
break;
case 'e':
return(kind);
case 'f':
goto Label_00C4;
case 'm':
goto Label_00D0;
default:
return(kind);
}
Label_00B9:
kind = NumberKind.Double;
this.NextChar();
return(kind);
Label_00C4:
kind = NumberKind.Float;
this.NextChar();
return(kind);
Label_00D0:
kind = NumberKind.Decimal;
this.NextChar();
return(kind);
}
private TokenID ScanDecimal()
{
string str;
TokenID integerLiteral;
NumberKind unsuffixedInteger = NumberKind.UnsuffixedInteger;
StringBuilder buffer = new StringBuilder();
char c = this.CurrentChar();
while (char.IsDigit(c))
{
buffer.Append(c);
c = this.NextChar();
}
switch (c)
{
case 'd':
case 'D':
unsuffixedInteger = NumberKind.Double;
this.NextChar();
break;
case 'e':
case 'E':
buffer.Append('e');
this.NextChar();
unsuffixedInteger = this.ScanExponent(buffer);
break;
case 'f':
case 'F':
unsuffixedInteger = NumberKind.Float;
this.NextChar();
break;
case 'm':
case 'M':
unsuffixedInteger = NumberKind.Decimal;
this.NextChar();
break;
case '.':
unsuffixedInteger = NumberKind.Double;
buffer.Append('.');
this.NextChar();
unsuffixedInteger = this.ScanFraction(buffer);
break;
default:
unsuffixedInteger = this.ScanOptionalIntegerSuffix();
break;
}
string s = buffer.ToString();
switch (unsuffixedInteger)
{
case NumberKind.Float:
integerLiteral = TokenID.FloatLiteral;
try
{
this.tokenValue = float.Parse(s, NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
return(integerLiteral);
}
catch (Exception exception)
{
str = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidFloatingPointConstant, new object[] { exception.Message });
throw new RuleSyntaxException(0x1a7, str, this.tokenStartPosition);
}
break;
case NumberKind.Double:
integerLiteral = TokenID.FloatLiteral;
try
{
this.tokenValue = double.Parse(s, NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
return(integerLiteral);
}
catch (Exception exception2)
{
str = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidFloatingPointConstant, new object[] { exception2.Message });
throw new RuleSyntaxException(0x1a7, str, this.tokenStartPosition);
}
break;
case NumberKind.Decimal:
integerLiteral = TokenID.DecimalLiteral;
try
{
this.tokenValue = decimal.Parse(s, NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
return(integerLiteral);
}
catch (Exception exception3)
{
str = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidDecimalConstant, new object[] { exception3.Message });
throw new RuleSyntaxException(0x1a7, str, this.tokenStartPosition);
}
break;
}
integerLiteral = TokenID.IntegerLiteral;
ulong num = 0L;
try
{
num = ulong.Parse(s, CultureInfo.InvariantCulture);
}
catch (Exception exception4)
{
str = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidIntegerConstant, new object[] { exception4.Message });
throw new RuleSyntaxException(0x192, str, this.tokenStartPosition);
}
switch (unsuffixedInteger)
{
case NumberKind.UnsuffixedInteger:
if (num <= 0x7fffffffffffffffL)
{
if (num <= 0x7fffffffL)
{
this.tokenValue = (int)num;
return(integerLiteral);
}
this.tokenValue = (long)num;
return(integerLiteral);
}
this.tokenValue = num;
return(integerLiteral);
case NumberKind.Long:
this.tokenValue = (long)num;
return(integerLiteral);
case (NumberKind.Long | NumberKind.UnsuffixedInteger):
case (NumberKind.Unsigned | NumberKind.UnsuffixedInteger):
return(integerLiteral);
case NumberKind.Unsigned:
if (num > 0xffffffffL)
{
this.tokenValue = num;
return(integerLiteral);
}
this.tokenValue = (uint)num;
return(integerLiteral);
case (NumberKind.Unsigned | NumberKind.Long):
this.tokenValue = num;
return(integerLiteral);
}
return(integerLiteral);
}
public Number(double d)
{
Value = d;
Kind = NumberKind.Double;
}
public Number(float f)
{
Value = f;
Kind = NumberKind.Single;
}
